@lobehub/editor 1.0.0

package/es/common/sys.js

@@ -0,0 +1,30 @@
+import { IS_APPLE } from '@lexical/utils';
+export var nodeDetect = function nodeDetect() {
+  return typeof process !== 'undefined' && process.versions && !!process.versions.node;
+};
+export var browserDetect = function browserDetect() {
+  return typeof window !== 'undefined' && window.document !== undefined;
+};
+export var isNode = nodeDetect();
+export var isBrowser = browserDetect();
+export var macOSDetect = function macOSDetect() {
+  if (isNode) {
+    return process.platform === 'darwin';
+  }
+  if (isBrowser) {
+    return window.navigator.platform.includes('Mac');
+  }
+  return false;
+};
+export var isMac = macOSDetect();
+export var CONTROL_OR_META = {
+  ctrlKey: !IS_APPLE,
+  metaKey: IS_APPLE
+};
+export var CONTROL_OR_META_AND_SHIFT = {
+  ctrlKey: !IS_APPLE,
+  metaKey: IS_APPLE,
+  shiftKey: true
+};
+export { IS_FIREFOX, IS_APPLE as isApple } from '@lexical/utils';
+export var isOnServerSide = typeof window === 'undefined';

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

@@ -0,0 +1,8 @@
+import { LexicalEditor } from 'lexical';
+export default class DataSource {
+    protected dataType: string;
+    constructor(dataType: string);
+    get type(): string;
+    read(editor: LexicalEditor, data: any): void;
+    write(editor: LexicalEditor): any;
+}

package/es/editor-kernel/data-source.js

@@ -0,0 +1,30 @@
+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); }
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable unused-imports/no-unused-vars */
+var DataSource = /*#__PURE__*/function () {
+  function DataSource(dataType) {
+    _classCallCheck(this, DataSource);
+    this.dataType = dataType;
+  }
+  _createClass(DataSource, [{
+    key: "type",
+    get: function get() {
+      return this.dataType;
+    }
+  }, {
+    key: "read",
+    value: function read(editor, data) {}
+  }, {
+    key: "write",
+    value: function write(editor) {
+      return null;
+    }
+  }]);
+  return DataSource;
+}();
+export { DataSource as default };

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

@@ -0,0 +1,3 @@
+import { LexicalEditor } from 'lexical';
+export declare const HOVER_COMMAND: import("lexical").LexicalCommand<MouseEvent>;
+export declare function registerEvent(editor: LexicalEditor, dom: HTMLElement): () => void;

package/es/editor-kernel/event.js

@@ -0,0 +1,11 @@
+import { createCommand } from 'lexical';
+export var HOVER_COMMAND = createCommand();
+export function registerEvent(editor, dom) {
+  var hoverHandler = function hoverHandler(event) {
+    editor.dispatchCommand(HOVER_COMMAND, event);
+  };
+  dom.addEventListener('mouseenter', hoverHandler);
+  return function () {
+    dom.removeEventListener('mouseenter', hoverHandler);
+  };
+}

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

@@ -0,0 +1,11 @@
+import type { IEditor } from "../types";
+export { default as DataSource } from './data-source';
+export * from './utils';
+/**
+ * Editor object to create an instance of the editor
+ */
+declare const Editor: {
+    createEditor(): IEditor;
+};
+export default Editor;
+export { HOVER_COMMAND } from './event';

package/es/editor-kernel/index.js

@@ -0,0 +1,14 @@
+import { Kernel } from "./kernel";
+export { default as DataSource } from "./data-source";
+export * from "./utils";
+
+/**
+ * Editor object to create an instance of the editor
+ */
+var Editor = {
+  createEditor: function createEditor() {
+    return new Kernel();
+  }
+};
+export default Editor;
+export { HOVER_COMMAND } from "./event";

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

@@ -0,0 +1,11 @@
+import { IElementNode } from './i-element-node';
+import { INode } from './i-node';
+import { IParagraphNode } from './paragraph-node';
+import { IRootNode } from './root-node';
+import { ITextNode } from './text-node';
+export declare const INodeHelper: {
+    appendChild(parent: IElementNode, child: INode): void;
+    createParagraph(attrs?: Record<string, unknown>): IParagraphNode;
+    createRootNode(attrs?: Record<string, unknown>): IRootNode;
+    createTextNode(text: string, attrs?: Record<string, unknown>): ITextNode;
+};

package/es/editor-kernel/inode/helper.js

@@ -0,0 +1,48 @@
+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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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); }
+var BaseContent = {
+  direction: 'ltr',
+  format: '',
+  indent: 0,
+  version: 1
+};
+export var INodeHelper = {
+  appendChild: function appendChild(parent, child) {
+    if (!parent.children) {
+      parent.children = [];
+    }
+    parent.children.push(child);
+  },
+  createParagraph: function createParagraph() {
+    var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return _objectSpread(_objectSpread(_objectSpread({}, BaseContent), {}, {
+      children: [],
+      textFormat: 0,
+      textStyle: ''
+    }, attrs), {}, {
+      type: 'paragraph'
+    });
+  },
+  createRootNode: function createRootNode() {
+    var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return _objectSpread(_objectSpread(_objectSpread({}, BaseContent), attrs), {}, {
+      children: [],
+      type: 'root'
+    });
+  },
+  createTextNode: function createTextNode(text) {
+    var attrs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return _objectSpread(_objectSpread(_objectSpread({}, BaseContent), {}, {
+      detail: 0,
+      mode: 'normal',
+      style: ''
+    }, attrs), {}, {
+      text: text,
+      type: 'text'
+    });
+  }
+};

package/es/editor-kernel/inode/i-element-node.d.ts

@@ -0,0 +1,5 @@
+import { INode } from './i-node';
+export interface IElementNode extends INode {
+    children: INode[];
+    type: string;
+}

package/es/editor-kernel/inode/i-element-node.js

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

package/es/editor-kernel/inode/i-node.d.ts

@@ -0,0 +1,6 @@
+export interface INode {
+    direction: 'ltr' | 'rtl';
+    format: string;
+    indent: number;
+    version: number;
+}

package/es/editor-kernel/inode/i-node.js

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

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

@@ -0,0 +1,5 @@
+export * from './i-element-node';
+export * from './i-node';
+export * from './paragraph-node';
+export * from './root-node';
+export * from './text-node';

package/es/editor-kernel/inode/index.js

@@ -0,0 +1,5 @@
+export * from "./i-element-node";
+export * from "./i-node";
+export * from "./paragraph-node";
+export * from "./root-node";
+export * from "./text-node";

package/es/editor-kernel/inode/paragraph-node.d.ts

@@ -0,0 +1,6 @@
+import { IElementNode } from './i-element-node';
+export interface IParagraphNode extends IElementNode {
+    textFormat: number;
+    textStyle: string;
+    type: 'paragraph';
+}

package/es/editor-kernel/inode/paragraph-node.js

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

package/es/editor-kernel/inode/root-node.d.ts

@@ -0,0 +1,7 @@
+import { IElementNode } from './i-element-node';
+/**
+ * Root node
+ */
+export interface IRootNode extends IElementNode {
+    type: 'root';
+}

package/es/editor-kernel/inode/root-node.js

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

package/es/editor-kernel/inode/text-node.d.ts

@@ -0,0 +1,12 @@
+import { TextModeType } from 'lexical';
+import { INode } from './i-node';
+/**
+ * Text node
+ */
+export interface ITextNode extends INode {
+    detail: number;
+    mode: TextModeType;
+    style: string;
+    text: string;
+    type: 'text';
+}

package/es/editor-kernel/inode/text-node.js

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

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

@@ -0,0 +1,46 @@
+import EventEmitter from 'eventemitter3';
+import { CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
+import DataSource from './data-source';
+import { IEditor, IEditorKernel, IEditorPluginConstructor, ILocaleKeys, IPlugin, IServiceID } from './types';
+export declare class Kernel extends EventEmitter implements IEditorKernel {
+    private dataTypeMap;
+    private plugins;
+    private pluginsInstances;
+    private nodes;
+    private themes;
+    private decorators;
+    private serviceMap;
+    private localeMap;
+    private editor?;
+    constructor();
+    getLexicalEditor(): LexicalEditor | null;
+    destroy(): void;
+    getRootElement(): HTMLElement | null;
+    setRootElement(dom: HTMLElement): LexicalEditor;
+    setDocument(type: string, content: any): void;
+    focus(): void;
+    blur(): void;
+    getDocument(type: string): DataSource | undefined;
+    registerDecorator(name: string, decorator: (_node: DecoratorNode<any>, _editor: LexicalEditor) => any): this;
+    getDecorator(name: string): ((_node: DecoratorNode<any>, _editor: LexicalEditor) => any) | undefined;
+    /**
+     * Support registering target data source
+     * @param dataSource Data source
+     */
+    registerDataSource(dataSource: DataSource): void;
+    registerThemes(themes: Record<string, any>): void;
+    registerPlugin<T>(plugin: IEditorPluginConstructor<T>, config?: T): IEditor;
+    registerPlugins(plugins: Array<IPlugin>): IEditor;
+    registerNodes(nodes: Array<LexicalNodeConfig>): void;
+    registerService<T>(serviceId: IServiceID<T>, service: T): void;
+    /**
+     * Get service
+     * @param serviceId Service ID
+     */
+    requireService<T>(serviceId: IServiceID<T>): T | null;
+    dispatchCommand<TCommand extends LexicalCommand<unknown>>(type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+    getTheme(): Record<string, any>;
+    updateTheme(key: string, value: string | Record<string, string>): void;
+    registerLocale(locale: Partial<Record<keyof ILocaleKeys, string>>): void;
+    t<K extends keyof ILocaleKeys>(key: K, params?: Record<string, any>): string;
+}

package/es/editor-kernel/kernel.js

@@ -0,0 +1,273 @@
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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 _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; }
+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 _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); }
+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 EventEmitter from 'eventemitter3';
+import { createEditor } from 'lexical';
+import { get, merge, template, templateSettings } from 'lodash-es';
+import defaultLocale from "../locale";
+import { registerEvent } from "./event";
+import { createEmptyEditorState } from "./utils";
+templateSettings.interpolate = /{{([\S\s]+?)}}/g;
+export var Kernel = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(Kernel, _EventEmitter);
+  var _super = _createSuper(Kernel);
+  function Kernel() {
+    var _this;
+    _classCallCheck(this, Kernel);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "dataTypeMap", void 0);
+    _defineProperty(_assertThisInitialized(_this), "plugins", []);
+    _defineProperty(_assertThisInitialized(_this), "pluginsInstances", []);
+    _defineProperty(_assertThisInitialized(_this), "nodes", []);
+    _defineProperty(_assertThisInitialized(_this), "themes", {});
+    // Used to store theme configuration
+    _defineProperty(_assertThisInitialized(_this), "decorators", {});
+    _defineProperty(_assertThisInitialized(_this), "serviceMap", new Map());
+    _defineProperty(_assertThisInitialized(_this), "localeMap", defaultLocale);
+    _defineProperty(_assertThisInitialized(_this), "editor", void 0);
+    _this.dataTypeMap = new Map();
+    return _this;
+  }
+  _createClass(Kernel, [{
+    key: "getLexicalEditor",
+    value: function getLexicalEditor() {
+      return this.editor || null;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this$editor;
+      (_this$editor = this.editor) === null || _this$editor === void 0 || _this$editor.setEditorState(createEmptyEditorState());
+      this.dataTypeMap.clear();
+      this.pluginsInstances.forEach(function (plugin) {
+        if (plugin.destroy) {
+          plugin.destroy();
+        }
+      });
+      this.pluginsInstances = [];
+    }
+  }, {
+    key: "getRootElement",
+    value: function getRootElement() {
+      var _this$editor2;
+      return ((_this$editor2 = this.editor) === null || _this$editor2 === void 0 ? void 0 : _this$editor2.getRootElement()) || null;
+    }
+  }, {
+    key: "setRootElement",
+    value: function setRootElement(dom) {
+      var _this2 = this;
+      var _iterator = _createForOfIteratorHelper(this.plugins),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var plugin = _step.value;
+          var instance = new plugin(this, plugin.__config);
+          this.pluginsInstances.push(instance);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var editor = this.editor = createEditor({
+        // @ts-expect-error Inject into lexical editor instance
+        __kernel: this,
+        nodes: this.nodes,
+        onError: function onError(error) {
+          _this2.emit('error', error);
+        },
+        theme: this.themes
+      });
+      this.editor.setRootElement(dom);
+      registerEvent(editor, dom);
+      this.pluginsInstances.forEach(function (plugin) {
+        var _plugin$onInit;
+        (_plugin$onInit = plugin.onInit) === null || _plugin$onInit === void 0 || _plugin$onInit.call(plugin, editor);
+      });
+      this.emit('initialized', editor);
+      return this.editor;
+    }
+  }, {
+    key: "setDocument",
+    value: function setDocument(type, content) {
+      var datasource = this.dataTypeMap.get(type);
+      if (!datasource) {
+        throw new Error("DataSource for type \"".concat(type, "\" is not registered."));
+      }
+      if (!this.editor) {
+        throw new Error("Editor is not initialized.");
+      }
+      datasource.read(this.editor, content);
+    }
+  }, {
+    key: "focus",
+    value: function focus() {
+      var _this$editor3;
+      (_this$editor3 = this.editor) === null || _this$editor3 === void 0 || _this$editor3.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      var _this$editor4;
+      (_this$editor4 = this.editor) === null || _this$editor4 === void 0 || _this$editor4.blur();
+    }
+  }, {
+    key: "getDocument",
+    value: function getDocument(type) {
+      var datasource = this.dataTypeMap.get(type);
+      if (!datasource) {
+        throw new Error("DataSource for type \"".concat(type, "\" is not registered."));
+      }
+      if (!this.editor) {
+        throw new Error("Editor is not initialized.");
+      }
+      return datasource.write(this.editor);
+    }
+  }, {
+    key: "registerDecorator",
+    value: function registerDecorator(name, decorator) {
+      this.decorators[name] = decorator;
+      return this;
+    }
+  }, {
+    key: "getDecorator",
+    value: function getDecorator(name) {
+      return this.decorators[name];
+    }
+
+    /**
+     * Support registering target data source
+     * @param dataSource Data source
+     */
+  }, {
+    key: "registerDataSource",
+    value: function registerDataSource(dataSource) {
+      this.dataTypeMap.set(dataSource.type, dataSource);
+    }
+  }, {
+    key: "registerThemes",
+    value: function registerThemes(themes) {
+      this.themes = merge(this.themes, themes);
+    }
+  }, {
+    key: "registerPlugin",
+    value: function registerPlugin(plugin, config) {
+      var findPlugin = this.plugins.find(function (p) {
+        return p.pluginName === plugin.pluginName;
+      });
+      if (findPlugin) {
+        // Error if same name but different plugin
+        if (findPlugin !== plugin) {
+          throw new Error("Plugin with name \"".concat(plugin.pluginName, "\" is already registered with a different implementation."));
+        }
+        return this; // If plugin already exists, don't register again
+      }
+      // @ts-expect-error not error
+      plugin.__config = config || {};
+      // @ts-expect-error not error
+      this.plugins.push(plugin);
+      return this;
+    }
+  }, {
+    key: "registerPlugins",
+    value: function registerPlugins(plugins) {
+      var _iterator2 = _createForOfIteratorHelper(plugins),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var plugin = _step2.value;
+          if (Array.isArray(plugin)) {
+            this.registerPlugin(plugin[0], plugin[1]);
+          } else {
+            this.registerPlugin(plugin);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return this;
+    }
+  }, {
+    key: "registerNodes",
+    value: function registerNodes(nodes) {
+      var _this$nodes;
+      (_this$nodes = this.nodes).push.apply(_this$nodes, _toConsumableArray(nodes));
+    }
+  }, {
+    key: "registerService",
+    value: function registerService(serviceId, service) {
+      if (this.serviceMap.has(serviceId.__serviceId)) {
+        throw new Error("Service with ID \"".concat(serviceId.__serviceId, "\" is already registered."));
+      }
+      this.serviceMap.set(serviceId.__serviceId, service);
+    }
+
+    /**
+     * Get service
+     * @param serviceId Service ID
+     */
+  }, {
+    key: "requireService",
+    value: function requireService(serviceId) {
+      var service = this.serviceMap.get(serviceId.__serviceId);
+      if (!service) {
+        return null;
+      }
+      return service;
+    }
+  }, {
+    key: "dispatchCommand",
+    value: function dispatchCommand(type, payload) {
+      if (!this.editor) {
+        throw new Error('Editor is not initialized.');
+      }
+      return this.editor.dispatchCommand(type, payload);
+    }
+  }, {
+    key: "getTheme",
+    value: function getTheme() {
+      return this.themes;
+    }
+  }, {
+    key: "updateTheme",
+    value: function updateTheme(key, value) {
+      this.themes[key] = value;
+    }
+  }, {
+    key: "registerLocale",
+    value: function registerLocale(locale) {
+      this.localeMap = merge(this.localeMap, locale);
+    }
+  }, {
+    key: "t",
+    value: function t(key, params) {
+      var translation = get(this.localeMap, key) || key;
+      if (params) {
+        var compiled = template(translation);
+        translation = compiled(params);
+      }
+      return translation;
+    }
+  }]);
+  return Kernel;
+}(EventEmitter);

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

@@ -0,0 +1,7 @@
+import EventEmitter from 'eventemitter3';
+export declare abstract class KernelPlugin extends EventEmitter {
+    protected clears: Array<() => void>;
+    protected register(clear: () => void): void;
+    protected registerClears(...clears: Array<() => void>): void;
+    destroy(): void;
+}

package/es/editor-kernel/plugin.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 _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); }
+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 EventEmitter from 'eventemitter3';
+export var KernelPlugin = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(KernelPlugin, _EventEmitter);
+  var _super = _createSuper(KernelPlugin);
+  function KernelPlugin() {
+    var _this;
+    _classCallCheck(this, KernelPlugin);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "clears", []);
+    return _this;
+  }
+  _createClass(KernelPlugin, [{
+    key: "register",
+    value: function register(clear) {
+      this.clears.push(clear);
+    }
+  }, {
+    key: "registerClears",
+    value: function registerClears() {
+      var _this2 = this;
+      for (var _len2 = arguments.length, clears = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        clears[_key2] = arguments[_key2];
+      }
+      clears.forEach(function (clear) {
+        return _this2.register(clear);
+      });
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.clears.forEach(function (clear) {
+        return clear();
+      });
+    }
+  }]);
+  return KernelPlugin;
+}(EventEmitter);