@lobehub/editor 1.0.0

package/es/editor-kernel/react/useToolbarState.js

@@ -0,0 +1,302 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { $createCodeNode, $isCodeNode } from '@lexical/code';
+import { $isListNode, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListNode } from '@lexical/list';
+import { $isHeadingNode } from '@lexical/rich-text';
+import { $isAtNodeEnd, $setBlocksType } from '@lexical/selection';
+import { $findMatchingParent, $getNearestNodeOfType, mergeRegister } from '@lexical/utils';
+import { $createParagraphNode, $getSelection, $isRangeSelection, $isRootOrShadowRoot, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, COMMAND_PRIORITY_LOW, FORMAT_TEXT_COMMAND, REDO_COMMAND, SELECTION_CHANGE_COMMAND, UNDO_COMMAND } from 'lexical';
+import { useCallback, useEffect, useState } from 'react';
+import { UPDATE_CODEBLOCK_LANG } from "../../plugins/codeblock";
+import { $isRootTextContentEmpty } from "../../plugins/common/utils";
+import { $isLinkNode, TOGGLE_LINK_COMMAND } from "../../plugins/link/node/LinkNode";
+import { sanitizeUrl } from "../../plugins/link/utils";
+function $findTopLevelElement(node) {
+  var topLevelElement = node.getKey() === 'root' ? node : $findMatchingParent(node, function (e) {
+    var parent = e.getParent();
+    return parent !== null && $isRootOrShadowRoot(parent);
+  });
+  if (topLevelElement === null) {
+    topLevelElement = node.getTopLevelElementOrThrow();
+  }
+  return topLevelElement;
+}
+var formatParagraph = function formatParagraph(editor) {
+  editor === null || editor === void 0 || editor.update(function () {
+    var selection = $getSelection();
+    $setBlocksType(selection, function () {
+      return $createParagraphNode();
+    });
+  });
+};
+function getSelectedNode(selection) {
+  var anchor = selection.anchor;
+  var focus = selection.focus;
+  var anchorNode = selection.anchor.getNode();
+  var focusNode = selection.focus.getNode();
+  if (anchorNode === focusNode) {
+    return anchorNode;
+  }
+  var isBackward = selection.isBackward();
+  if (isBackward) {
+    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+  } else {
+    return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+  }
+}
+
+/**
+ * Provide toolbar state and toolbar methods
+ * @returns
+ */
+export function useToolbarState(editorRef) {
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    canUndo = _useState2[0],
+    setCanUndo = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    canRedo = _useState4[0],
+    setCanRedo = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    isBold = _useState6[0],
+    setIsBold = _useState6[1];
+  var _useState7 = useState(false),
+    _useState8 = _slicedToArray(_useState7, 2),
+    isItalic = _useState8[0],
+    setIsItalic = _useState8[1];
+  var _useState9 = useState(false),
+    _useState10 = _slicedToArray(_useState9, 2),
+    isUnderline = _useState10[0],
+    setIsUnderline = _useState10[1];
+  var _useState11 = useState(false),
+    _useState12 = _slicedToArray(_useState11, 2),
+    isStrikethrough = _useState12[0],
+    setIsStrikethrough = _useState12[1];
+  var _useState13 = useState(false),
+    _useState14 = _slicedToArray(_useState13, 2),
+    isCode = _useState14[0],
+    setIsCode = _useState14[1];
+  var _useState15 = useState(false),
+    _useState16 = _slicedToArray(_useState15, 2),
+    isLink = _useState16[0],
+    setIsLink = _useState16[1];
+  var _useState17 = useState(false),
+    _useState18 = _slicedToArray(_useState17, 2),
+    isInCodeblock = _useState18[0],
+    setIsInCodeblok = _useState18[1];
+  var _useState19 = useState(null),
+    _useState20 = _slicedToArray(_useState19, 2),
+    codeblockLang = _useState20[0],
+    setCodeblockLang = _useState20[1];
+  var _useState21 = useState(true),
+    _useState22 = _slicedToArray(_useState21, 2),
+    isEmpty = _useState22[0],
+    setIsEmpty = _useState22[1];
+  var _useState23 = useState(null),
+    _useState24 = _slicedToArray(_useState23, 2),
+    blockType = _useState24[0],
+    setBlockType = _useState24[1];
+  var $handleHeadingNode = useCallback(function (selectedElement) {
+    var type = $isHeadingNode(selectedElement) ? selectedElement.getTag() : selectedElement.getType();
+    setBlockType(type);
+  }, [setBlockType]);
+  var $updateToolbar = useCallback(function () {
+    var _editorRef$current;
+    var selection = $getSelection();
+    var editor = (_editorRef$current = editorRef.current) === null || _editorRef$current === void 0 ? void 0 : _editorRef$current.getLexicalEditor();
+    if (editor) {
+      setIsEmpty($isRootTextContentEmpty(editor.isComposing(), false));
+    }
+    if ($isRangeSelection(selection)) {
+      var _editorRef$current2;
+      setIsBold(selection.hasFormat('bold'));
+      setIsItalic(selection.hasFormat('italic'));
+      setIsUnderline(selection.hasFormat('underline'));
+      setIsStrikethrough(selection.hasFormat('strikethrough'));
+      setIsCode(selection.hasFormat('code'));
+      var anchorNode = selection.anchor.getNode();
+      var focusNode = selection.focus.getNode();
+      var element = $findTopLevelElement(anchorNode);
+      var focusElement = $findTopLevelElement(focusNode);
+      var elementKey = element.getKey();
+      var elementDOM = (_editorRef$current2 = editorRef.current) === null || _editorRef$current2 === void 0 || (_editorRef$current2 = _editorRef$current2.getLexicalEditor()) === null || _editorRef$current2 === void 0 ? void 0 : _editorRef$current2.getElementByKey(elementKey);
+      var node = getSelectedNode(selection);
+      var parent = node.getParent();
+      setIsLink($isLinkNode(parent) || $isLinkNode(node));
+      var isCodeBlock = $isCodeNode(element) && $isCodeNode(focusElement) && elementKey === focusElement.getKey();
+      setIsInCodeblok(isCodeBlock);
+      setCodeblockLang(isCodeBlock ? element.getLanguage() : '');
+      if (elementDOM !== null) {
+        if ($isListNode(element)) {
+          var parentList = $getNearestNodeOfType(anchorNode, ListNode);
+          var type = parentList ? parentList.getListType() : element.getListType();
+          setBlockType(type);
+        } else {
+          $handleHeadingNode(element);
+        }
+      }
+    } else if (!selection) {
+      setIsBold(false);
+      setIsItalic(false);
+      setIsUnderline(false);
+      setIsStrikethrough(false);
+      setIsCode(false);
+      setIsLink(false);
+      setIsInCodeblok(false);
+      setCodeblockLang(null);
+      setBlockType(null);
+    }
+  }, [editorRef.current]);
+  var undo = useCallback(function () {
+    var _editorRef$current3;
+    (_editorRef$current3 = editorRef.current) === null || _editorRef$current3 === void 0 || _editorRef$current3.dispatchCommand(UNDO_COMMAND, undefined);
+  }, [editorRef.current]);
+  var redo = useCallback(function () {
+    var _editorRef$current4;
+    (_editorRef$current4 = editorRef.current) === null || _editorRef$current4 === void 0 || _editorRef$current4.dispatchCommand(REDO_COMMAND, undefined);
+  }, [editorRef.current]);
+  var formatText = useCallback(function (type) {
+    var _editorRef$current5;
+    (_editorRef$current5 = editorRef.current) === null || _editorRef$current5 === void 0 || _editorRef$current5.dispatchCommand(FORMAT_TEXT_COMMAND, type);
+  }, [editorRef.current]);
+  var bold = useCallback(function () {
+    formatText('bold');
+  }, [formatText]);
+  var underline = useCallback(function () {
+    formatText('underline');
+  }, [formatText]);
+  var strikethrough = useCallback(function () {
+    formatText('strikethrough');
+  }, [formatText]);
+  var italic = useCallback(function () {
+    formatText('italic');
+  }, [formatText]);
+  var code = useCallback(function () {
+    formatText('code');
+  }, [formatText]);
+  var bulletList = useCallback(function () {
+    if (blockType !== 'bullet') {
+      var _editorRef$current6;
+      (_editorRef$current6 = editorRef.current) === null || _editorRef$current6 === void 0 || _editorRef$current6.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
+    } else {
+      var _editorRef$current7;
+      formatParagraph((_editorRef$current7 = editorRef.current) === null || _editorRef$current7 === void 0 ? void 0 : _editorRef$current7.getLexicalEditor());
+    }
+  }, [blockType]);
+  var numberList = useCallback(function () {
+    if (blockType !== 'number') {
+      var _editorRef$current8;
+      (_editorRef$current8 = editorRef.current) === null || _editorRef$current8 === void 0 || _editorRef$current8.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined);
+    } else {
+      var _editorRef$current9;
+      formatParagraph((_editorRef$current9 = editorRef.current) === null || _editorRef$current9 === void 0 ? void 0 : _editorRef$current9.getLexicalEditor());
+    }
+  }, [blockType]);
+  var formatCodeblock = useCallback(function () {
+    if (blockType !== 'code') {
+      var _editorRef$current10;
+      (_editorRef$current10 = editorRef.current) === null || _editorRef$current10 === void 0 || (_editorRef$current10 = _editorRef$current10.getLexicalEditor()) === null || _editorRef$current10 === void 0 || _editorRef$current10.update(function () {
+        var selection = $getSelection();
+        if (!selection) {
+          return;
+        }
+        if (!$isRangeSelection(selection) || selection.isCollapsed()) {
+          $setBlocksType(selection, function () {
+            return $createCodeNode();
+          });
+        } else {
+          var textContent = selection.getTextContent();
+          var codeNode = $createCodeNode();
+          selection.insertNodes([codeNode]);
+          selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            selection.insertRawText(textContent);
+          }
+        }
+      });
+    }
+  }, [blockType]);
+  var updateCodeblockLang = useCallback(function (lang) {
+    var _editorRef$current11;
+    if (!isInCodeblock) {
+      return;
+    }
+    (_editorRef$current11 = editorRef.current) === null || _editorRef$current11 === void 0 || _editorRef$current11.dispatchCommand(UPDATE_CODEBLOCK_LANG, {
+      lang: lang
+    });
+  }, [editorRef.current, isInCodeblock]);
+  var insertLink = useCallback(function () {
+    if (!isLink) {
+      var _editorRef$current12;
+      setIsLink(true);
+      (_editorRef$current12 = editorRef.current) === null || _editorRef$current12 === void 0 || (_editorRef$current12 = _editorRef$current12.getLexicalEditor()) === null || _editorRef$current12 === void 0 || _editorRef$current12.dispatchCommand(TOGGLE_LINK_COMMAND, sanitizeUrl('https://'));
+    } else {
+      var _editorRef$current13;
+      setIsLink(false);
+      (_editorRef$current13 = editorRef.current) === null || _editorRef$current13 === void 0 || (_editorRef$current13 = _editorRef$current13.getLexicalEditor()) === null || _editorRef$current13 === void 0 || _editorRef$current13.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+    }
+  }, [editorRef.current, isLink]);
+  useEffect(function () {
+    if (!editorRef.current) return;
+    var editor = editorRef.current;
+    var lexicalEditor = editor.getLexicalEditor();
+    var cleanup = function cleanup() {};
+    var handleLeixcalEditor = function handleLeixcalEditor(editor) {
+      cleanup = mergeRegister(editor.registerUpdateListener(function (_ref) {
+        var editorState = _ref.editorState;
+        editorState.read(function () {
+          $updateToolbar();
+        });
+      }), editor.registerCommand(SELECTION_CHANGE_COMMAND, function () {
+        $updateToolbar();
+        return false;
+      }, COMMAND_PRIORITY_LOW), editor.registerCommand(CAN_UNDO_COMMAND, function (payload) {
+        setCanUndo(payload);
+        return false;
+      }, COMMAND_PRIORITY_LOW), editor.registerCommand(CAN_REDO_COMMAND, function (payload) {
+        setCanRedo(payload);
+        return false;
+      }, COMMAND_PRIORITY_LOW));
+      return cleanup;
+    };
+    if (!lexicalEditor) {
+      editor.on('initialized', handleLeixcalEditor);
+      return function () {
+        cleanup();
+        editor.off('initialized', handleLeixcalEditor);
+      };
+    }
+    return handleLeixcalEditor(lexicalEditor);
+  }, [editorRef.current]);
+  return {
+    blockType: blockType,
+    bold: bold,
+    bulletList: bulletList,
+    canRedo: canRedo,
+    canUndo: canUndo,
+    code: code,
+    codeblockLang: codeblockLang,
+    formatCodeblock: formatCodeblock,
+    insertLink: insertLink,
+    isBold: isBold,
+    isCode: isCode,
+    isEmpty: isEmpty,
+    isInCodeblock: isInCodeblock,
+    isItalic: isItalic,
+    isStrikethrough: isStrikethrough,
+    isUnderline: isUnderline,
+    italic: italic,
+    numberList: numberList,
+    redo: redo,
+    strikethrough: strikethrough,
+    underline: underline,
+    undo: undo,
+    updateCodeblockLang: updateCodeblockLang
+  };
+}

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

@@ -0,0 +1,3 @@
+import { TFunction } from "../../types";
+export declare function useTranslation(): TFunction;
+export declare const useLocale: typeof useTranslation;

package/es/editor-kernel/react/useTranslation.js

@@ -0,0 +1,19 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback } from 'react';
+import { useLexicalComposerContext } from "./react-context";
+export function useTranslation() {
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  return useCallback(function (key, options) {
+    return editor.t(key, options);
+  }, [editor]);
+}
+
+// Maintain backward compatibility
+export var useLocale = useTranslation;

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

@@ -0,0 +1,189 @@
+import type { CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
+import type DataSource from './data-source';
+/**
+ * Internationalization key type declaration, plugins can extend through declaration merging
+ */
+export type LocaleType = typeof import("../locale").default;
+type FlattenKeys<T, Prefix extends string = ''> = {
+    [K in keyof T & string]: T[K] extends string ? Prefix extends '' ? K : `${Prefix}.${K}` : T[K] extends Record<string, any> ? FlattenKeys<T[K], Prefix extends '' ? K : `${Prefix}.${K}`> : never;
+}[keyof T & string];
+export type TFunction = <TKey extends FlattenKeys<LocaleType>>(key: TKey, options?: Record<string, string | number>) => string;
+export type ILocaleKeys = Record<FlattenKeys<LocaleType>, string>;
+/**
+ * Service ID type
+ */
+export type IServiceID<Service> = {
+    readonly __serviceId: string;
+    __serviceType?: Service;
+};
+export interface IKernelEventMap {
+    /**
+     * Editor error event
+     */
+    error: (error: Error) => void;
+    /**
+     * Initialization event
+     * @param editor Lexical editor instance
+     * @returns
+     */
+    initialized: (editor: LexicalEditor) => void;
+}
+/**
+ * External API
+ */
+export interface IEditor {
+    /**
+     * Lose focus
+     */
+    blur(): void;
+    /**
+     * Destroy editor instance
+     */
+    destroy(): void;
+    /**
+     * Execute editor commands to manipulate editor content
+     * @param type
+     * @param payload
+     */
+    dispatchCommand<TCommand extends LexicalCommand<unknown>>(type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+    /**
+     * Focus editor
+     */
+    focus(): void;
+    /**
+     * Get editor content of specified type
+     */
+    getDocument(type: string): DataSource | undefined;
+    /**
+     * Get Lexical editor instance
+     */
+    getLexicalEditor(): LexicalEditor | null;
+    /**
+     * Get document editor root node
+     */
+    getRootElement(): HTMLElement | null;
+    /**
+     * Get editor theme
+     */
+    getTheme(): Record<string, string | Record<string, string>>;
+    /**
+     * Remove editor event listener
+     * @param event
+     * @param listener
+     */
+    off<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+    /**
+     * Add editor event listener
+     * @param event
+     * @param listener
+     */
+    on<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+    /**
+     * Listen to event once, automatically remove listener after trigger
+     * @param event
+     * @param listener
+     */
+    once<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+    /**
+     * Register internationalization text
+     * @param locale Internationalization text object
+     */
+    registerLocale(locale: Partial<Record<keyof ILocaleKeys, string>>): void;
+    /**
+     * Register editor plugin
+     */
+    registerPlugin<T>(plugin: IEditorPluginConstructor<T>, config?: T): IEditor;
+    /**
+     * Register multiple editor plugins
+     */
+    registerPlugins(plugins: Array<IPlugin>): IEditor;
+    /**
+     * Get editor Service, usually provided by plugins to extend certain functionalities
+     * @param serviceId
+     */
+    requireService<T>(serviceId: IServiceID<T>): T | null;
+    /**
+     * Set editor content, type is content type, content is content data
+     * @param type
+     * @param content
+     */
+    setDocument(type: string, content: any): void;
+    /**
+     * Set document editor root node
+     * @param dom
+     */
+    setRootElement(dom: HTMLElement): LexicalEditor;
+    /**
+     * Get translation text
+     * @param key Translation key
+     * @param params Parameter replacement
+     */
+    t<K extends keyof ILocaleKeys>(key: K, params?: Record<string, any>): string;
+    /**
+     * Update editor theme
+     * @param key
+     * @param value
+     */
+    updateTheme(key: string, value: string | Record<string, string>): void;
+}
+/**
+ * API provided to plugins
+ */
+export interface IEditorKernel extends IEditor {
+    /**
+     * Get editor Node decorator for specific Node rendering
+     * @param name
+     */
+    getDecorator(name: string): ((_node: DecoratorNode<any>, _editor: LexicalEditor) => any) | undefined;
+    /**
+     * Register data source for multi-format data conversion
+     * @param dataSource
+     */
+    registerDataSource(dataSource: DataSource): void;
+    /**
+     * Register editor node decorator
+     * @param name
+     * @param decorator
+     */
+    registerDecorator(name: string, decorator: (_node: DecoratorNode<any>, _editor: LexicalEditor) => any): void;
+    /**
+     * Register Lexical Node
+     * @param nodes
+     */
+    registerNodes(nodes: Array<LexicalNodeConfig>): void;
+    /**
+     * Register service
+     * @param serviceId
+     * @param service
+     */
+    registerService<T>(serviceId: IServiceID<T>, service: T): void;
+    /**
+     * Register theme
+     * @param themes
+     */
+    registerThemes(themes: Record<string, any>): void;
+}
+/**
+ * Plugin interface
+ */
+export interface IEditorPlugin<IConfig> {
+    config?: IConfig;
+    /**
+     * Editor destruction
+     */
+    destroy(): void;
+    /**
+     * After Lexical editor instantiation
+     * @param editor Lexical editor instance
+     */
+    onInit?(editor: LexicalEditor): void;
+}
+/**
+ * Plugin class interface
+ */
+export interface IEditorPluginConstructor<IConfig> {
+    readonly pluginName: string;
+    new (kernel: IEditorKernel, config?: IConfig): IEditorPlugin<IConfig>;
+}
+export type IPlugin<T = any> = IEditorPluginConstructor<T> | [IEditorPluginConstructor<T>, T?];
+export {};

package/es/editor-kernel/types.js

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

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

@@ -0,0 +1,25 @@
+import { EditorState, LexicalEditor, LexicalNode, NodeKey } from 'lexical';
+import type { IEditorKernel, IServiceID } from "../types";
+export declare const DOM_ELEMENT_TYPE = 1;
+export declare const DOM_TEXT_TYPE = 3;
+export declare const DOM_DOCUMENT_TYPE = 9;
+export declare const DOM_DOCUMENT_FRAGMENT_TYPE = 11;
+export declare function genServiceId<T>(name: string): IServiceID<T>;
+export declare const noop: () => void;
+export declare function createEmptyEditorState(): EditorState;
+export declare function assert(cond?: boolean, message?: string): asserts cond;
+export declare function getNodeKeyFromDOMNode(dom: Node, editor: LexicalEditor): NodeKey | undefined;
+export declare function $getNodeFromDOMNode(dom: Node, editor: LexicalEditor, editorState?: EditorState): LexicalNode | null;
+/**
+ * @param x - The element being tested
+ * @returns Returns true if x is a DOM Node, false otherwise.
+ */
+export declare function isDOMNode(x: unknown): x is Node;
+/**
+ * @param x - The element being testing
+ * @returns Returns true if x is a document fragment, false otherwise.
+ */
+export declare function isDocumentFragment(x: unknown): x is DocumentFragment;
+export declare function getParentElement(node: Node): HTMLElement | null;
+export declare function $getNearestNodeFromDOMNode(startingDOM: Node, editor: LexicalEditor, editorState?: EditorState): LexicalNode | null;
+export declare function getKernelFromEditor(editor: LexicalEditor): IEditorKernel;

package/es/editor-kernel/utils.js

@@ -0,0 +1,69 @@
+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); }
+import { $getNodeByKey, EditorState } from 'lexical';
+// DOM
+export var DOM_ELEMENT_TYPE = 1;
+export var DOM_TEXT_TYPE = 3;
+export var DOM_DOCUMENT_TYPE = 9;
+export var DOM_DOCUMENT_FRAGMENT_TYPE = 11;
+export function genServiceId(name) {
+  return {
+    __serviceId: name
+  };
+}
+export var noop = function noop() {};
+export function createEmptyEditorState() {
+  return new EditorState(new Map(), null);
+}
+export function assert(cond, message) {
+  if (cond) {
+    return;
+  }
+  throw new Error(message);
+}
+export function getNodeKeyFromDOMNode(dom, editor) {
+  var prop = "__lexicalKey_".concat(editor._key);
+  return dom[prop];
+}
+export function $getNodeFromDOMNode(dom, editor, editorState) {
+  var key = getNodeKeyFromDOMNode(dom, editor);
+  if (key !== undefined) {
+    return $getNodeByKey(key, editorState);
+  }
+  return null;
+}
+
+/**
+ * @param x - The element being tested
+ * @returns Returns true if x is a DOM Node, false otherwise.
+ */
+export function isDOMNode(x) {
+  return _typeof(x) === 'object' && x !== null && 'nodeType' in x && typeof x.nodeType === 'number';
+}
+
+/**
+ * @param x - The element being testing
+ * @returns Returns true if x is a document fragment, false otherwise.
+ */
+export function isDocumentFragment(x) {
+  return isDOMNode(x) && x.nodeType === DOM_DOCUMENT_FRAGMENT_TYPE;
+}
+export function getParentElement(node) {
+  var parentElement = node.assignedSlot || node.parentElement;
+  return isDocumentFragment(parentElement) ? parentElement.host : parentElement;
+}
+export function $getNearestNodeFromDOMNode(startingDOM, editor, editorState) {
+  var dom = startingDOM;
+  while (dom !== null) {
+    var node = $getNodeFromDOMNode(dom, editor, editorState);
+    if (node !== null) {
+      return node;
+    }
+    dom = getParentElement(dom);
+  }
+  return null;
+}
+export function getKernelFromEditor(editor) {
+  var _editor$_createEditor;
+  // @ts-expect-error __kernel is injected into the lexical editor instance
+  return ((_editor$_createEditor = editor._createEditorArgs) === null || _editor$_createEditor === void 0 ? void 0 : _editor$_createEditor.__kernel) || editor._kernel;
+}

package/es/index.d.ts

@@ -0,0 +1,14 @@
+export * from './editor-kernel';
+export * from './editor-kernel/react';
+export * from './plugins/codeblock';
+export * from './plugins/common';
+export * from './plugins/file';
+export * from './plugins/hr';
+export * from './plugins/image';
+export * from './plugins/link';
+export * from './plugins/list';
+export * from './plugins/mention';
+export * from './plugins/slash';
+export * from './plugins/table';
+export * from './plugins/upload';
+export type { IEditor } from './types';

package/es/index.js

@@ -0,0 +1,14 @@
+export * from "./editor-kernel";
+export * from "./editor-kernel/react";
+export * from "./plugins/codeblock";
+export * from "./plugins/common";
+export * from "./plugins/file";
+export * from "./plugins/hr";
+export * from "./plugins/image";
+export * from "./plugins/link";
+export * from "./plugins/list";
+export * from "./plugins/mention";
+export * from "./plugins/slash";
+export * from "./plugins/table";
+export * from "./plugins/upload";
+export {};

package/es/locale/index.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    file: {
+        error: string;
+        uploading: string;
+    };
+    image: {
+        broken: string;
+    };
+    link: {
+        edit: string;
+        open: string;
+        placeholder: string;
+        unlink: string;
+    };
+    table: {
+        delete: string;
+        deleteColumn: string;
+        deleteRow: string;
+        insertColumnLeft: string;
+        insertColumnRight: string;
+        insertRowAbove: string;
+        insertRowBelow: string;
+    };
+};
+export default _default;