@lobehub/editor 1.4.7 → 1.5.0

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

@@ -1,5 +1,5 @@
 import EventEmitter from 'eventemitter3';
-import { CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
+import { CommandListener, CommandListenerPriority, CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
 import { IEditor, IEditorKernel, IEditorPluginConstructor, IPlugin, IServiceID } from "../types/kernel";
 import { ILocaleKeys } from "../types/locale";
 import DataSource from './data-source';
@@ -75,4 +75,7 @@ export declare class Kernel extends EventEmitter implements IEditorKernel {
     get isEmpty(): boolean;
     get isSelected(): boolean;
     cleanDocument(): void;
+    private _commands;
+    private _commandsClean;
+    registerHighCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
 }

package/es/editor-kernel/kernel.js

@@ -20,7 +20,7 @@ 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 EventEmitter from 'eventemitter3';
-import { $getSelection, $isRangeSelection, createEditor } from 'lexical';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, createEditor } from 'lexical';
 import { get, merge, template, templateSettings } from 'lodash-es';
 import defaultLocale from "../locale";
 import { $isRootTextContentEmpty } from "../plugins/common/utils";
@@ -45,6 +45,8 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     _defineProperty(_assertThisInitialized(_this), "localeMap", defaultLocale);
     _defineProperty(_assertThisInitialized(_this), "hotReloadMode", false);
     _defineProperty(_assertThisInitialized(_this), "editor", void 0);
+    _defineProperty(_assertThisInitialized(_this), "_commands", new Map());
+    _defineProperty(_assertThisInitialized(_this), "_commandsClean", new Map());
     _this.dataTypeMap = new Map();
     // Enable hot reload mode in development
     _this.hotReloadMode = _this.detectDevelopmentMode();
@@ -153,6 +155,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       var editor = this.editor = createEditor({
         // @ts-expect-error Inject into lexical editor instance
         __kernel: this,
+        namespace: 'lobehub',
         nodes: this.nodes,
         onError: function onError(error) {
           _this2.emit('error', error);
@@ -452,6 +455,58 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     value: function cleanDocument() {
       this.setDocument('text', '');
     }
+  }, {
+    key: "registerHighCommand",
+    value: function registerHighCommand(command, listener, priority) {
+      var _this4 = this;
+      var lexicalEditor = this.editor;
+      if (!lexicalEditor) {
+        throw new Error('Editor is not initialized.');
+      }
+      var commandsMap = this._commands;
+      if (!commandsMap.has(command)) {
+        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 = _this4._commands.get(command);
+            if (listenerInPriorityOrder !== undefined) {
+              var listenersSet = listenerInPriorityOrder[i];
+              var _iterator3 = _createForOfIteratorHelper(listenersSet),
+                _step3;
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  var _listener = _step3.value;
+                  if (_listener(payload, lexicalEditor)) {
+                    return true;
+                  }
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+            }
+          }
+          return false;
+        }, COMMAND_PRIORITY_CRITICAL));
+      }
+      var listenersInPriorityOrder = commandsMap.get(command);
+      if (listenersInPriorityOrder === undefined) {
+        return function () {};
+      }
+      var listeners = listenersInPriorityOrder[priority];
+      listeners.add(listener);
+      return function () {
+        listeners.delete(listener);
+        if (listenersInPriorityOrder.every(function (listenersSet) {
+          return listenersSet.size === 0;
+        })) {
+          var _this4$_commandsClean;
+          commandsMap.delete(command);
+          (_this4$_commandsClean = _this4._commandsClean.get(command)) === null || _this4$_commandsClean === void 0 || _this4$_commandsClean();
+        }
+      };
+    }
   }], [{
     key: "setGlobalHotReloadMode",
     value: function setGlobalHotReloadMode(enabled) {

package/es/index.d.ts

@@ -1,5 +1,6 @@
 export * from './editor-kernel';
 export * from './editor-kernel/react';
+export * from './plugins/code';
 export * from './plugins/codeblock';
 export * from './plugins/common';
 export * from './plugins/file';
@@ -7,6 +8,7 @@ export * from './plugins/hr';
 export * from './plugins/image';
 export * from './plugins/link';
 export * from './plugins/list';
+export * from './plugins/math';
 export * from './plugins/mention';
 export * from './plugins/slash';
 export * from './plugins/table';

package/es/index.js

@@ -1,5 +1,6 @@
 export * from "./editor-kernel";
 export * from "./editor-kernel/react";
+export * from "./plugins/code";
 export * from "./plugins/codeblock";
 export * from "./plugins/common";
 export * from "./plugins/file";
@@ -7,6 +8,7 @@ export * from "./plugins/hr";
 export * from "./plugins/image";
 export * from "./plugins/link";
 export * from "./plugins/list";
+export * from "./plugins/math";
 export * from "./plugins/mention";
 export * from "./plugins/slash";
 export * from "./plugins/table";

package/es/locale/index.d.ts

@@ -1,4 +1,6 @@
 declare const _default: {
+    cancel: string;
+    confirm: string;
     file: {
         error: string;
         uploading: string;
@@ -8,10 +10,15 @@ declare const _default: {
     };
     link: {
         edit: string;
+        editLinkTitle: string;
+        editTextTitle: string;
         open: string;
         placeholder: string;
         unlink: string;
     };
+    math: {
+        placeholder: string;
+    };
     table: {
         delete: string;
         deleteColumn: string;

package/es/locale/index.js

@@ -1,4 +1,6 @@
 export default {
+  cancel: 'Cancel',
+  confirm: 'Confirm',
   file: {
     error: 'Error: {{message}}',
     uploading: 'Uploading file...'
@@ -8,10 +10,15 @@ export default {
   },
   link: {
     edit: 'Edit Link',
+    editLinkTitle: 'Link',
+    editTextTitle: 'Text',
     open: 'Open Link',
     placeholder: 'Enter link URL',
     unlink: 'Unlink Link'
   },
+  math: {
+    placeholder: 'Enter TeX formula'
+  },
   table: {
     delete: 'Delete table',
     deleteColumn: 'Delete column',

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

@@ -0,0 +1,3 @@
+import { LexicalEditor } from 'lexical';
+export declare const INSERT_CODEINLINE_COMMAND: import("lexical").LexicalCommand<undefined>;
+export declare function registerCodeInlineCommand(editor: LexicalEditor): () => void;

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

@@ -0,0 +1,48 @@
+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; }
+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";
+export var INSERT_CODEINLINE_COMMAND = createCommand('INSERT_CODEINLINE_COMMAND');
+export function registerCodeInlineCommand(editor) {
+  return editor.registerCommand(INSERT_CODEINLINE_COMMAND, function () {
+    editor.update(function () {
+      var selection = $getSelection();
+      if (!selection || !$isRangeSelection(selection)) {
+        return false;
+      }
+      var focusNode = selection.focus.getNode();
+      var anchorNode = selection.anchor.getNode();
+      if ($isCodeHighlightNode(focusNode) || $isCodeHighlightNode(anchorNode)) {
+        return false;
+      }
+      if (focusNode.getParent() !== anchorNode.getParent()) {
+        return false;
+      }
+      var parentNode = focusNode.getParent();
+      if ($isCodeInlineNode(parentNode)) {
+        var _iterator = _createForOfIteratorHelper(parentNode.getChildren().slice(0)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var node = _step.value;
+            parentNode.insertBefore(node);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        parentNode.remove();
+        return true;
+      }
+      var codeNode = $createCodeNode(selection.getTextContent());
+      $insertNodes([codeNode, $createCursorNode()]);
+      codeNode.select();
+    });
+    return true;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  );
+}

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

@@ -0,0 +1,3 @@
+export { INSERT_CODEINLINE_COMMAND } from './command';
+export { CodePlugin } from './plugin';
+export { ReactCodePlugin } from './react';

package/es/plugins/code/index.js

@@ -0,0 +1,3 @@
+export { INSERT_CODEINLINE_COMMAND } from "./command";
+export { CodePlugin } from "./plugin";
+export { ReactCodePlugin } from "./react";

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

@@ -0,0 +1,19 @@
+import { EditorConfig, LexicalEditor, SerializedElementNode } from 'lexical';
+import { CardLikeElementNode } from "../../common";
+export type SerializedCodeNode = SerializedElementNode;
+export declare class CodeNode extends CardLikeElementNode {
+    static getType(): string;
+    static clone(node: CodeNode): CodeNode;
+    static importJSON(serializedNode: SerializedCodeNode): CodeNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    getDOMSlot(element: HTMLElement): import("lexical").ElementDOMSlot<HTMLElement>;
+    canBeEmpty(): boolean;
+    isCardLike(): boolean;
+    isInline(): boolean;
+    canIndent(): boolean;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+}
+export declare function $createCodeNode(textContent?: string): CodeNode;
+export declare function $isCodeInlineNode(node: unknown): node is CodeNode;
+export declare function $isSelectionInCodeInline(editor: LexicalEditor): boolean;

package/es/plugins/{common/node/LexicalLineBreakNode.js → code/node/code.js}

@@ -4,6 +4,8 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 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); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
@@ -11,130 +13,126 @@ function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) ===
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-import { $applyNodeReplacement, DecoratorNode, isBlockDomNode, isDOMTextNode } from 'lexical';
-var LexicalNodeImpl = DecoratorNode.prototype.constructor;
-
-/** @noInheritDoc */
-export var LineBreakNode = /*#__PURE__*/function (_LexicalNodeImpl) {
-  _inherits(LineBreakNode, _LexicalNodeImpl);
-  var _super = _createSuper(LineBreakNode);
-  function LineBreakNode() {
-    _classCallCheck(this, LineBreakNode);
+/* 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";
+export var CodeNode = /*#__PURE__*/function (_CardLikeElementNode) {
+  _inherits(CodeNode, _CardLikeElementNode);
+  var _super = _createSuper(CodeNode);
+  function CodeNode() {
+    _classCallCheck(this, CodeNode);
     return _super.apply(this, arguments);
   }
-  _createClass(LineBreakNode, [{
-    key: "getTextContent",
-    value: function getTextContent() {
-      return '\n';
+  _createClass(CodeNode, [{
+    key: "createDOM",
+    value: function createDOM(config) {
+      var element = document.createElement('span');
+      // eslint-disable-next-line unicorn/prefer-dom-node-dataset
+      element.setAttribute('data-lexical-key', this.getKey());
+      // const filler = document.createElement('t-filler');
+      // filler.contentEditable = 'false';
+      // filler.innerHTML = '\uFEFF';
+      // eslint-disable-next-line unicorn/prefer-dom-node-dataset
+      // filler.setAttribute('data-lexical-cursor', 'true');
+      // element.append(filler);
+      var childContainer = document.createElement('ne-content');
+      element.append(childContainer);
+      addClassNamesToElement(element, config.theme.codeInline);
+      return element;
     }
   }, {
-    key: "createDOM",
-    value: function createDOM() {
-      return document.createElement('br');
+    key: "getDOMSlot",
+    value: function getDOMSlot(element) {
+      var neContent = element.querySelector('ne-content');
+      if (!neContent) {
+        throw new Error('CodeNode: ne-content not found');
+      }
+      return _get(_getPrototypeOf(CodeNode.prototype), "getDOMSlot", this).call(this, element).withElement(neContent);
     }
   }, {
-    key: "updateDOM",
-    value: function updateDOM() {
+    key: "canBeEmpty",
+    value: function canBeEmpty() {
       return false;
     }
+  }, {
+    key: "isCardLike",
+    value: function isCardLike() {
+      return true;
+    }
   }, {
     key: "isInline",
     value: function isInline() {
       return true;
     }
+  }, {
+    key: "canIndent",
+    value: function canIndent() {
+      return false;
+    }
+  }, {
+    key: "canInsertTextBefore",
+    value: function canInsertTextBefore() {
+      return true;
+    }
+  }, {
+    key: "canInsertTextAfter",
+    value: function canInsertTextAfter() {
+      return true;
+    }
   }], [{
     key: "getType",
     value: function getType() {
-      return 'linebreak';
+      return 'codeInline';
     }
   }, {
     key: "clone",
     value: function clone(node) {
-      return new LineBreakNode(node.__key);
-    }
-  }, {
-    key: "importDOM",
-    value: function importDOM() {
-      return {
-        br: function br(node) {
-          // eslint-disable-next-line @typescript-eslint/no-use-before-define
-          if (isOnlyChildInBlockNode(node) || isLastChildInBlockNode(node)) {
-            return null;
-          }
-          return {
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            conversion: $convertLineBreakElement,
-            priority: 0
-          };
-        }
-      };
+      return new CodeNode(node.__key);
     }
   }, {
     key: "importJSON",
-    value: function importJSON(serializedLineBreakNode) {
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      return $createLineBreakNode().updateFromJSON(serializedLineBreakNode);
+    value: function importJSON(serializedNode) {
+      return $createCodeNode().updateFromJSON(serializedNode);
     }
   }]);
-  return LineBreakNode;
-}(LexicalNodeImpl);
-function $convertLineBreakElement() {
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  return {
-    node: $createLineBreakNode()
-  };
-}
-export function $createLineBreakNode() {
-  return $applyNodeReplacement(new LineBreakNode());
+  return CodeNode;
+}(CardLikeElementNode);
+export function $createCodeNode(textContent) {
+  var codeNode = $applyNodeReplacement(new CodeNode());
+  var cursorNode = $createCursorNode();
+  codeNode.append(cursorNode);
+  if (textContent) {
+    codeNode.append($createTextNode(textContent));
+  }
+  return codeNode;
 }
-export function $isLineBreakNode(node) {
-  return node instanceof LineBreakNode;
+export function $isCodeInlineNode(node) {
+  return node instanceof CodeNode;
 }
-function isOnlyChildInBlockNode(node) {
-  var parentElement = node.parentElement;
-  if (parentElement !== null && isBlockDomNode(parentElement)) {
-    var firstChild = parentElement.firstChild;
-    if (firstChild === node ||
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
-      var lastChild = parentElement.lastChild;
-      if (lastChild === node || lastChild.previousSibling === node &&
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      isWhitespaceDomTextNode(lastChild)) {
+export function $isSelectionInCodeInline(editor) {
+  return editor.read(function () {
+    var selection = $getSelection();
+    if (!selection) {
+      return false;
+    }
+    if ($isRangeSelection(selection)) {
+      var focusNode = selection.focus.getNode();
+      var anchorNode = selection.anchor.getNode();
+      if (focusNode.getParent() !== anchorNode.getParent()) {
+        return false;
+      }
+      var parentNode = focusNode.getParent();
+      if ($isCodeInlineNode(parentNode)) {
         return true;
       }
-    }
-  }
-  return false;
-}
-function isLastChildInBlockNode(node) {
-  var parentElement = node.parentElement;
-  if (parentElement !== null && isBlockDomNode(parentElement)) {
-    // check if node is first child, because only child dont count
-    var firstChild = parentElement.firstChild;
-    if (firstChild === node ||
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
       return false;
+    } else if ($isNodeSelection(selection)) {
+      var nodes = selection.getNodes();
+      if (nodes.length === 1 && $isCodeInlineNode(nodes[0])) {
+        return true;
+      }
     }
-
-    // check if its last child
-    var lastChild = parentElement.lastChild;
-    if (lastChild === node ||
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isWhitespaceDomTextNode(node) {
-  return isDOMTextNode(node) && /^( |\t|\r?\n)+$/.test(node.textContent || '');
+    return false;
+  });
 }

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

@@ -0,0 +1,5 @@
+import { IEditorPluginConstructor } from "../../../types";
+export interface CodePluginOptions {
+    theme?: string;
+}
+export declare const CodePlugin: IEditorPluginConstructor<CodePluginOptions>;

package/es/plugins/{common/node/ParagraphNode.js → code/plugin/index.js}

@@ -1,11 +1,8 @@
+var _class;
 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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-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); }
-function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
@@ -13,35 +10,45 @@ function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) ===
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-import { ParagraphNode } from 'lexical';
-import { MElementDOMSlot } from "./ElementDOMSlot";
-export var MParagraphNode = /*#__PURE__*/function (_ParagraphNode) {
-  _inherits(MParagraphNode, _ParagraphNode);
-  var _super = _createSuper(MParagraphNode);
-  function MParagraphNode() {
-    _classCallCheck(this, MParagraphNode);
-    return _super.apply(this, arguments);
+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 { KernelPlugin } from "../../../editor-kernel/plugin";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
+import { registerCodeInlineCommand } from "../command";
+import { CodeNode } from "../node/code";
+import { registerCodeInline } from "./registry";
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+export var CodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(CodePlugin, _KernelPlugin);
+  var _super = _createSuper(CodePlugin);
+  function CodePlugin(kernel, options) {
+    var _this;
+    _classCallCheck(this, CodePlugin);
+    _this = _super.call(this);
+    _this.kernel = kernel;
+    kernel.registerNodes([CodeNode]);
+    kernel.registerThemes({
+      codeInline: (options === null || options === void 0 ? void 0 : options.theme) || 'editor-code'
+    });
+    return _this;
   }
-  _createClass(MParagraphNode, [{
-    key: "createDOM",
-    value: function createDOM(config) {
-      return _get(_getPrototypeOf(MParagraphNode.prototype), "createDOM", this).call(this, config);
-    }
-  }, {
-    key: "getDOMSlot",
-    value: function getDOMSlot(element) {
-      return new MElementDOMSlot(element);
-    }
-  }], [{
-    key: "getType",
-    value: function getType() {
-      return 'paragraph';
-    }
-  }, {
-    key: "clone",
-    value: function clone(node) {
-      return new MParagraphNode(node.__key);
+  _createClass(CodePlugin, [{
+    key: "onInit",
+    value: function onInit(editor) {
+      this.register(registerCodeInlineCommand(editor));
+      this.register(registerCodeInline(editor, this.kernel));
+      var markdownService = this.kernel.requireService(IMarkdownShortCutService);
+      if (!markdownService) {
+        return;
+      }
+      markdownService.registerMarkdownWriter(CodeNode.getType(), function (ctx, node) {
+        ctx.appendLine("`".concat(node.getTextContent(), "`"));
+        return true;
+      });
     }
   }]);
-  return MParagraphNode;
-}(ParagraphNode);
+  return CodePlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'CodePlugin'), _class);

package/es/plugins/code/plugin/registry.d.ts

@@ -0,0 +1,3 @@
+import { LexicalEditor } from 'lexical';
+import { IEditorKernel } from "../../../types";
+export declare function registerCodeInline(editor: LexicalEditor, kernel: IEditorKernel): () => void;