@lobehub/editor 1.0.0

package/es/plugins/codeblock/react/style.js

@@ -0,0 +1,38 @@
+var _templateObject, _templateObject2;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { createStyles } from 'antd-style';
+export var useStyles = createStyles(function (_ref) {
+  var css = _ref.css,
+    token = _ref.token,
+    stylish = _ref.stylish,
+    isDarkMode = _ref.isDarkMode;
+  return {
+    code: css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    --color-yellow: ", ";\n    --color-error: ", ";\n    --color-gray: ", ";\n    --color-purple: ", ";\n    --color-info: ", ";\n    --color-success: ", ";\n    --color-warning: ", ";\n    --color-text: ", ";\n    --color-geekblue: ", ";\n    --color-purple10: ", ";\n    --color-warning-text-active: ", ";\n    --color-yellow11: ", ";\n\n    position: relative;\n\n    overflow: hidden;\n    display: block;\n\n    width: 100%;\n    margin-block: calc(var(--lobe-markdown-margin-multiple) * 0.5em);\n    padding: 16px;\n    border-radius: calc(var(--lobe-markdown-border-radius) * 1px);\n\n    font-family: ", ";\n    font-size: calc(var(--lobe-markdown-font-size) * 0.85);\n\n    background: ", " !important;\n    box-shadow: 0 0 0 1px var(--lobe-markdown-border-color) inset;\n\n    &::after {\n      border-radius: ", "px;\n\n      content: attr(data-language);\n\n      padding-block: 1px;\n      padding-inline: 7px;\n\n      font-size: 12px;\n\n      display: block;\n\n      position: absolute;\n      z-index: 3;\n      inset-block-end: 8px;\n      inset-inline-end: 8px;\n\n      font-family: ", ";\n      color: ", ";\n\n      background: ", ";\n\n      transition: opacity 0.1s;\n\n      opacity: 0;\n\n      ", "\n    }\n\n    span {\n      color: var(", ");\n    }\n\n    &:hover {\n      &::after {\n        opacity: 1;\n      }\n    }\n  "])), token.yellow, token.colorError, token.gray, token.purple10, token.colorInfo, token.colorSuccess, token.colorWarning, token.colorText, token.geekblue, token.purple10, token.colorWarningTextActive, token.yellow11, token.fontFamilyCode, token.colorFillTertiary, token.borderRadius, token.fontFamilyCode, token.colorTextSecondary, token.colorFillQuaternary, stylish.blur, isDarkMode ? '--shiki-dark' : '--shiki-light'),
+    noBackground: css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    background: transparent !important;\n  "])))
+  };
+});
+export var colorReplacements = {
+  'slack-dark': {
+    '#4ec9b0': 'var(--color-yellow)',
+    '#569cd6': 'var(--color-error)',
+    '#6a9955': 'var(--color-gray)',
+    '#9cdcfe': 'var(--color-text)',
+    '#b5cea8': 'var(--color-purple10)',
+    '#c586c0': 'var(--color-info)',
+    '#ce9178': 'var(--color-success)',
+    '#dcdcaa': 'var(--color-warning)',
+    '#e6e6e6': 'var(--color-text)'
+  },
+  'slack-ochin': {
+    '#002339': 'var(--color-text)',
+    '#0444ac': 'var(--color-geekblue)',
+    '#0991b6': 'var(--color-error)',
+    '#174781': 'var(--color-purple10)',
+    '#2f86d2': 'var(--color-text)',
+    '#357b42': 'var(--color-gray)',
+    '#7b30d0': 'var(--color-info)',
+    '#7eb233': 'var(--color-warning-text-active)',
+    '#a44185': 'var(--color-success)',
+    '#dc3eb7': 'var(--color-yellow11)'
+  }
+};

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

@@ -0,0 +1,5 @@
+import type { CodeblockPluginOptions } from "..";
+export interface ReactCodeblockPluginProps extends CodeblockPluginOptions {
+    className?: string;
+    shikiTheme?: string;
+}

package/es/plugins/codeblock/react/type.js

@@ -0,0 +1 @@
+export {};

package/es/plugins/codeblock/utils/language.d.ts

@@ -0,0 +1 @@
+export declare function getCodeLanguageByInput(input: string): string;

package/es/plugins/codeblock/utils/language.js

@@ -0,0 +1,12 @@
+import { bundledLanguagesInfo } from 'shiki';
+export function getCodeLanguageByInput(input) {
+  if (!input) {
+    return 'plaintext';
+  }
+  var inputLang = input.toLocaleLowerCase();
+  var matchLang = bundledLanguagesInfo.find(function (lang) {
+    var _lang$aliases;
+    return lang.id === inputLang || ((_lang$aliases = lang.aliases) === null || _lang$aliases === void 0 ? void 0 : _lang$aliases.includes(inputLang));
+  });
+  return (matchLang === null || matchLang === void 0 ? void 0 : matchLang.id) || 'plaintext';
+}

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

@@ -0,0 +1,7 @@
+import { HeadingTagType } from '@lexical/rich-text';
+import { LexicalEditor } from 'lexical';
+export declare const INSERT_QUOTE_COMMAND: import("lexical").LexicalCommand<unknown>;
+export declare const INSERT_HEADING_COMMAND: import("lexical").LexicalCommand<{
+    tag: HeadingTagType;
+}>;
+export declare function registerCommands(editor: LexicalEditor): () => void;

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

@@ -0,0 +1,31 @@
+import { $createHeadingNode, $createQuoteNode } from '@lexical/rich-text';
+import { $setBlocksType } from '@lexical/selection';
+import { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
+export var INSERT_QUOTE_COMMAND = createCommand('INSERT_QUOTE_COMMAND');
+export var INSERT_HEADING_COMMAND = createCommand('INSERT_HEADING_COMMAND');
+export function registerCommands(editor) {
+  return mergeRegister(editor.registerCommand(INSERT_QUOTE_COMMAND, function () {
+    editor.update(function () {
+      var selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        $setBlocksType(selection, function () {
+          return $createQuoteNode();
+        });
+      }
+    });
+    return true;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  ), editor.registerCommand(INSERT_HEADING_COMMAND, function (payload) {
+    editor.update(function () {
+      var selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        $setBlocksType(selection, function () {
+          return $createHeadingNode(payload.tag);
+        });
+      }
+    });
+    return true;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  ));
+}

package/es/plugins/common/data-source/json-data-source.d.ts

@@ -0,0 +1,7 @@
+import { EditorState, LexicalEditor } from 'lexical';
+import { DataSource } from "../../../editor-kernel";
+export declare function createEmptyEditorState(): EditorState;
+export default class JSONDataSource extends DataSource {
+    read(editor: LexicalEditor, data: any): void;
+    write(editor: LexicalEditor): any;
+}

package/es/plugins/common/data-source/json-data-source.js

@@ -0,0 +1,39 @@
+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 _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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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 { EditorState, RootNode } from 'lexical';
+import { DataSource } from "../../../editor-kernel";
+export function createEmptyEditorState() {
+  return new EditorState(new Map([['root', new RootNode()]]));
+}
+var JSONDataSource = /*#__PURE__*/function (_DataSource) {
+  _inherits(JSONDataSource, _DataSource);
+  var _super = _createSuper(JSONDataSource);
+  function JSONDataSource() {
+    _classCallCheck(this, JSONDataSource);
+    return _super.apply(this, arguments);
+  }
+  _createClass(JSONDataSource, [{
+    key: "read",
+    value: function read(editor, data) {
+      editor.setEditorState(editor.parseEditorState(data));
+    }
+  }, {
+    key: "write",
+    value: function write(editor) {
+      return editor.getEditorState().toJSON();
+    }
+  }]);
+  return JSONDataSource;
+}(DataSource);
+export { JSONDataSource as default };

package/es/plugins/common/data-source/text-data-source.d.ts

@@ -0,0 +1,6 @@
+import { LexicalEditor } from 'lexical';
+import { DataSource } from "../../../editor-kernel";
+export default class TextDataSource extends DataSource {
+    read(editor: LexicalEditor, data: string): void;
+    write(editor: LexicalEditor): any;
+}

package/es/plugins/common/data-source/text-data-source.js

@@ -0,0 +1,54 @@
+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 _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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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 { $getRoot } from 'lexical';
+import { DataSource } from "../../../editor-kernel";
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
+var TextDataSource = /*#__PURE__*/function (_DataSource) {
+  _inherits(TextDataSource, _DataSource);
+  var _super = _createSuper(TextDataSource);
+  function TextDataSource() {
+    _classCallCheck(this, TextDataSource);
+    return _super.apply(this, arguments);
+  }
+  _createClass(TextDataSource, [{
+    key: "read",
+    value: function read(editor, data) {
+      if (typeof data !== 'string') {
+        throw new Error('Invalid data type ' + _typeof(data));
+      }
+      var lines = data.split(/\n/g);
+      var rootNode = INodeHelper.createRootNode();
+      lines.forEach(function (line) {
+        var paragraph = INodeHelper.createParagraph();
+        if (line) {
+          var textNode = INodeHelper.createTextNode(line);
+          INodeHelper.appendChild(paragraph, textNode);
+        }
+        INodeHelper.appendChild(rootNode, paragraph);
+      });
+      editor.setEditorState(editor.parseEditorState({
+        root: rootNode
+      }));
+    }
+  }, {
+    key: "write",
+    value: function write(editor) {
+      return editor.getEditorState().read(function () {
+        return $getRoot().getTextContent();
+      });
+    }
+  }]);
+  return TextDataSource;
+}(DataSource);
+export { TextDataSource as default };

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

@@ -0,0 +1,3 @@
+export { INSERT_HEADING_COMMAND, INSERT_QUOTE_COMMAND } from './command';
+export * from './plugin';
+export * from './react';

package/es/plugins/common/index.js

@@ -0,0 +1,3 @@
+export { INSERT_HEADING_COMMAND, INSERT_QUOTE_COMMAND } from "./command";
+export * from "./plugin";
+export * from "./react";

package/es/plugins/common/node/ElementDOMSlot.d.ts

@@ -0,0 +1,5 @@
+import { ElementDOMSlot } from 'lexical';
+export declare class MElementDOMSlot extends ElementDOMSlot {
+    setManagedLineBreak(lineBreakType: null | 'empty' | 'line-break' | 'decorator'): void;
+    insertManagedLineBreak(webkitHack: boolean): void;
+}

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

@@ -0,0 +1,59 @@
+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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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 { ElementDOMSlot } from 'lexical';
+export var MElementDOMSlot = /*#__PURE__*/function (_ElementDOMSlot) {
+  _inherits(MElementDOMSlot, _ElementDOMSlot);
+  var _super = _createSuper(MElementDOMSlot);
+  function MElementDOMSlot() {
+    _classCallCheck(this, MElementDOMSlot);
+    return _super.apply(this, arguments);
+  }
+  _createClass(MElementDOMSlot, [{
+    key: "setManagedLineBreak",
+    value: function setManagedLineBreak(lineBreakType) {
+      _get(_getPrototypeOf(MElementDOMSlot.prototype), "setManagedLineBreak", this).call(this, lineBreakType);
+    }
+  }, {
+    key: "insertManagedLineBreak",
+    value: function insertManagedLineBreak(webkitHack) {
+      var prevBreak = this.getManagedLineBreak();
+      if (prevBreak) {
+        if (webkitHack === (prevBreak.nodeName === 'IMG')) {
+          return;
+        }
+        this.removeManagedLineBreak();
+      }
+      var element = this.element;
+      var before = this.before;
+      var br = document.createElement('br');
+      // eslint-disable-next-line unicorn/prefer-modern-dom-apis
+      element.insertBefore(br, before);
+      if (webkitHack) {
+        var img = document.createElement('img');
+        // eslint-disable-next-line unicorn/prefer-dom-node-dataset
+        img.setAttribute('data-lexical-linebreak', 'true');
+        img.style.cssText = 'display: inline !important; border: 0px !important; margin: 0px !important;';
+        img.alt = '';
+        // eslint-disable-next-line unicorn/prefer-modern-dom-apis
+        element.insertBefore(img, br);
+        element.__lexicalLineBreak = img;
+      } else {
+        element.__lexicalLineBreak = br;
+      }
+    }
+  }]);
+  return MElementDOMSlot;
+}(ElementDOMSlot);

package/es/plugins/common/node/LexicalLineBreakNode.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { DOMConversionMap, DecoratorNode, LexicalNode, SerializedLexicalNode } from 'lexical';
+export type SerializedLineBreakNode = SerializedLexicalNode;
+declare const LexicalNodeImpl: import("lexical").KlassConstructor<{
+    new (key?: string | undefined): DecoratorNode<any>;
+    getType(): string;
+    clone(_data: unknown): LexicalNode;
+    importDOM?: (() => DOMConversionMap<any> | null) | undefined;
+    importJSON(_serializedNode: SerializedLexicalNode): LexicalNode;
+    transform(): ((node: LexicalNode) => void) | null;
+}>;
+/** @noInheritDoc */
+export declare class LineBreakNode extends LexicalNodeImpl {
+    static getType(): string;
+    static clone(node: LineBreakNode): LineBreakNode;
+    getTextContent(): '\n';
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    isInline(): true;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedLineBreakNode: SerializedLineBreakNode): LineBreakNode;
+}
+export declare function $createLineBreakNode(): LineBreakNode;
+export declare function $isLineBreakNode(node: LexicalNode | null | undefined): node is LineBreakNode;
+export {};

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

@@ -0,0 +1,140 @@
+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 _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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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);
+    return _super.apply(this, arguments);
+  }
+  _createClass(LineBreakNode, [{
+    key: "getTextContent",
+    value: function getTextContent() {
+      return '\n';
+    }
+  }, {
+    key: "createDOM",
+    value: function createDOM() {
+      return document.createElement('br');
+    }
+  }, {
+    key: "updateDOM",
+    value: function updateDOM() {
+      return false;
+    }
+  }, {
+    key: "isInline",
+    value: function isInline() {
+      return true;
+    }
+  }], [{
+    key: "getType",
+    value: function getType() {
+      return 'linebreak';
+    }
+  }, {
+    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
+          };
+        }
+      };
+    }
+  }, {
+    key: "importJSON",
+    value: function importJSON(serializedLineBreakNode) {
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      return $createLineBreakNode().updateFromJSON(serializedLineBreakNode);
+    }
+  }]);
+  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());
+}
+export function $isLineBreakNode(node) {
+  return node instanceof LineBreakNode;
+}
+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)) {
+        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;
+    }
+
+    // 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 || '');
+}

package/es/plugins/common/node/ParagraphNode.d.ts

@@ -0,0 +1,7 @@
+import { EditorConfig, ElementDOMSlot, ParagraphNode } from 'lexical';
+export declare class MParagraphNode extends ParagraphNode {
+    static getType(): string;
+    static clone(node: ParagraphNode): ParagraphNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLElement>;
+}

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

@@ -0,0 +1,47 @@
+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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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);
+  }
+  _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);
+    }
+  }]);
+  return MParagraphNode;
+}(ParagraphNode);

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

@@ -0,0 +1,16 @@
+import { IEditorPluginConstructor } from "../../../types";
+export interface CommonPluginOptions {
+    theme?: {
+        quote?: string;
+        textBold?: string;
+        textCode?: string;
+        textHighlight?: string;
+        textItalic?: string;
+        textStrikethrough?: string;
+        textSubscript?: string;
+        textSuperscript?: string;
+        textUnderline?: string;
+        textUnderlineStrikethrough?: string;
+    };
+}
+export declare const CommonPlugin: IEditorPluginConstructor<CommonPluginOptions>;