@lobehub/editor 4.5.0 → 4.6.1

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

@@ -1,25 +0,0 @@
-import { createContext as createReactContext, use } from 'react';
-import { assert } from "../utils";
-export var LexicalComposerContext = /*#__PURE__*/createReactContext(null);
-export function createLexicalComposerContext(parent, theme) {
-  var parentContext = null;
-  if (parent) {
-    parentContext = parent[1];
-  }
-  function getTheme() {
-    if (theme !== null) {
-      return theme;
-    }
-    return parentContext !== null ? parentContext.getTheme() : null;
-  }
-  return {
-    getTheme: getTheme
-  };
-}
-export function useLexicalComposerContext() {
-  var composerContext = use(LexicalComposerContext);
-  if (!composerContext) {
-    assert(false, 'LexicalComposerContext.useLexicalComposerContext: cannot find a LexicalComposerContext');
-  }
-  return composerContext;
-}

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

@@ -1,15 +0,0 @@
-/**
- * Support configuration through react children
- */
-import { type FC, type ReactNode } from 'react';
-import type { IEditor } from "../../types";
-export interface IReactEditorProps {
-    children?: ReactNode | undefined;
-    /** Editor configuration */
-    config?: Record<string, any>;
-    /** Editor instance to use */
-    editor?: IEditor;
-    /** Callback called when editor is initialized */
-    onInit?: (editor: IEditor) => void;
-}
-export declare const ReactEditor: FC<IReactEditorProps>;

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

@@ -1,52 +0,0 @@
-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; }
-/**
- * Support configuration through react children
- */
-import { useEffect, useMemo } from 'react';
-import Editor from "../";
-import { LexicalComposerContext, createLexicalComposerContext, useLexicalComposerContext } from "./react-context";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
-// Configuration injection component
-var ConfigInjector = function ConfigInjector(_ref) {
-  var config = _ref.config;
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  useEffect(function () {
-    if (config !== null && config !== void 0 && config.locale && Object.keys(config.locale).length > 0) {
-      editor.registerLocale(config.locale);
-    }
-  }, [editor, config]);
-  return null;
-};
-export var ReactEditor = function ReactEditor(_ref2) {
-  var editorProp = _ref2.editor,
-    children = _ref2.children,
-    config = _ref2.config,
-    onInit = _ref2.onInit;
-  var composerContext = useMemo(function () {
-    var editor = editorProp || Editor.createEditor();
-    var theme = createLexicalComposerContext(null, null);
-    return [editor, theme];
-  }, [editorProp]);
-  useEffect(function () {
-    var editor = composerContext[0];
-
-    // Call onInit callback
-    if (onInit) {
-      onInit(editor);
-    }
-  }, [composerContext, onInit]);
-  return /*#__PURE__*/_jsxs(LexicalComposerContext, {
-    value: composerContext,
-    children: [/*#__PURE__*/_jsx(ConfigInjector, {
-      config: config
-    }), children]
-  });
-};

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

@@ -1 +0,0 @@
-export declare const useAnchor: () => HTMLElement | undefined;

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

@@ -1,27 +0,0 @@
-'use client';
-
-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 { LOBE_THEME_APP_ID } from '@lobehub/ui';
-import { useMemo } from 'react';
-import { useLexicalComposerContext } from "./react-context";
-export var useAnchor = function useAnchor() {
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  // Don't render portal on server side
-
-  return useMemo(function () {
-    if (typeof document === 'undefined' || !editor) return;
-    var root = editor.getRootElement();
-    var anchor = root ? root.parentElement : null;
-    if (anchor) return anchor;
-    // Fallback to .ant-app if exists, otherwise document.body
-    var app = document.querySelector("#".concat(LOBE_THEME_APP_ID));
-    return app || document.body;
-  }, [editor]);
-};

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

@@ -1,9 +0,0 @@
-import { type ComponentClass, type FC, type JSX } from 'react';
-import { IEditor } from "../../types";
-type ErrorBoundaryProps = {
-    children: JSX.Element;
-    onError: (error: unknown) => void;
-};
-export type ErrorBoundaryType = ComponentClass<ErrorBoundaryProps> | FC<ErrorBoundaryProps>;
-export declare function useDecorators(editor: IEditor, ErrorBoundary: ErrorBoundaryType): Array<JSX.Element>;
-export {};

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

@@ -1,80 +0,0 @@
-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 { Suspense, useEffect, useLayoutEffect, useMemo, useState } from 'react';
-import { createPortal, flushSync } from 'react-dom';
-import { CAN_USE_DOM } from "../../common/canUseDOM";
-import { jsx as _jsx } from "react/jsx-runtime";
-// This workaround is no longer necessary in React 19,
-// but we currently support React >=17.x
-// https://github.com/facebook/react/pull/26395
-var useLayoutEffectImpl = CAN_USE_DOM ? useLayoutEffect : useEffect;
-export function useDecorators(editor, ErrorBoundary) {
-  var _useState = useState(function () {
-      var _editor$getLexicalEdi;
-      return ((_editor$getLexicalEdi = editor.getLexicalEditor()) === null || _editor$getLexicalEdi === void 0 ? void 0 : _editor$getLexicalEdi.getDecorators()) || {};
-    }),
-    _useState2 = _slicedToArray(_useState, 2),
-    decorators = _useState2[0],
-    setDecorators = _useState2[1];
-
-  // Subscribe to changes
-  useLayoutEffectImpl(function () {
-    var clears = [];
-    var handleInit = function handleInit(editor) {
-      // Get initial decorators
-      var initialDecorators = editor.getDecorators();
-      setDecorators(initialDecorators);
-      clears.push(editor.registerDecoratorListener(function (nextDecorators) {
-        flushSync(function () {
-          setDecorators(nextDecorators);
-        });
-      }));
-    };
-
-    // Check if editor is already initialized
-    var lexicalEditor = editor.getLexicalEditor();
-    if (lexicalEditor) {
-      handleInit(lexicalEditor);
-    } else {
-      editor.on('initialized', handleInit);
-      clears.push(function () {
-        editor.off('initialized', handleInit);
-      });
-    }
-    return function () {
-      clears.forEach(function (clear) {
-        return clear();
-      });
-    };
-  }, [editor]);
-
-  // Return decorators defined as React Portals
-  return useMemo(function () {
-    var decoratedPortals = [];
-    var decoratorKeys = Object.keys(decorators);
-    for (var _i = 0, _decoratorKeys = decoratorKeys; _i < _decoratorKeys.length; _i++) {
-      var _editor$getLexicalEdi3;
-      var nodeKey = _decoratorKeys[_i];
-      var decorator = decorators[nodeKey];
-      var reactDecorator = /*#__PURE__*/_jsx(ErrorBoundary, {
-        onError: function onError(e) {
-          var _editor$getLexicalEdi2;
-          return (_editor$getLexicalEdi2 = editor.getLexicalEditor()) === null || _editor$getLexicalEdi2 === void 0 ? void 0 : _editor$getLexicalEdi2._onError(e);
-        },
-        children: /*#__PURE__*/_jsx(Suspense, {
-          fallback: null,
-          children: 'render' in decorator ? decorator.render : decorator
-        })
-      });
-      var element = (_editor$getLexicalEdi3 = editor.getLexicalEditor()) === null || _editor$getLexicalEdi3 === void 0 ? void 0 : _editor$getLexicalEdi3.getElementByKey(nodeKey);
-      if (element !== null && element !== undefined) {
-        decoratedPortals.push( /*#__PURE__*/createPortal(reactDecorator, 'queryDOM' in decorator ? decorator.queryDOM(element) : element, nodeKey));
-      }
-    }
-    return decoratedPortals;
-  }, [ErrorBoundary, decorators, editor]);
-}

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

@@ -1,3 +0,0 @@
-export declare const useEditable: () => {
-    editable: boolean;
-};

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

@@ -1,37 +0,0 @@
-'use client';
-
-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 { useEffect, useState } from 'react';
-import { useLexicalComposerContext } from "./react-context";
-export var useEditable = function useEditable() {
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  // Don't render portal on server side
-  var _useState = useState(editor.isEditable()),
-    _useState2 = _slicedToArray(_useState, 2),
-    editable = _useState2[0],
-    setEditable = _useState2[1];
-  useEffect(function () {
-    var updateEditable = function updateEditable(newEditable) {
-      setEditable(newEditable);
-    };
-    var handleInitialized = function handleInitialized() {
-      setEditable(editor.isEditable());
-    };
-    editor.on('editableChange', updateEditable);
-    editor.on('initialized', handleInitialized);
-    return function () {
-      editor.off('editableChange', updateEditable);
-      editor.off('initialized', handleInitialized);
-    };
-  }, [editor]);
-  return {
-    editable: editable
-  };
-};

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

@@ -1,2 +0,0 @@
-import { LexicalEditor } from 'lexical';
-export declare function useLexicalEditor(handleEditor: (lexicalEditor: LexicalEditor) => (() => void) | undefined, deps?: any[]): void;

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

@@ -1,31 +0,0 @@
-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 { useEffect } from 'react';
-import { useLexicalComposerContext } from "./react-context";
-export function useLexicalEditor(handleEditor) {
-  var deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  useEffect(function () {
-    var lexicalEditor = editor.getLexicalEditor();
-    if (lexicalEditor) {
-      return handleEditor(lexicalEditor);
-    } else {
-      var remove = undefined;
-      var handle = function handle(editor) {
-        remove = handleEditor(editor);
-      };
-      editor.on('initialized', handle);
-      return function () {
-        var _remove;
-        editor.off('initialized', handle);
-        (_remove = remove) === null || _remove === void 0 || _remove();
-      };
-    }
-  }, deps);
-}

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

@@ -1,17 +0,0 @@
-import type { NodeKey } from 'lexical';
-/**
- * A custom hook to manage the selection state of a specific node in a Lexical editor.
- *
- * This hook provides utilities to:
- * - Check if a node is selected.
- * - Update its selection state.
- * - Clear the selection.
- *
- * @param {NodeKey} key - The key of the node to track selection for.
- * @returns {[boolean, (selected: boolean) => void, () => void]} A tuple containing:
- * - `isSelected` (boolean): Whether the node is currently selected.
- * - `setSelected` (function): A function to set the selection state of the node.
- * - `clearSelected` (function): A function to clear the selection of the node.
- *
- */
-export declare function useLexicalNodeSelection(key: NodeKey): [boolean, (selected: boolean) => void, () => void, boolean];

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

@@ -1,120 +0,0 @@
-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 { $createNodeSelection, $getNodeByKey, $getSelection, $isNodeSelection, $setSelection } from 'lexical';
-import { useCallback, useEffect, useState } from 'react';
-import { useLexicalComposerContext } from "./react-context";
-
-/**
- * A helper function to determine if a specific node is selected in a Lexical editor.
- *
- * @param {LexicalEditor} editor - The LexicalEditor instance.
- * @param {NodeKey} key - The key of the node to check.
- * @returns {boolean} Whether the node is selected.
- */
-
-function isNodeSelected(editor, key) {
-  if (!editor) return false;
-  return editor.getEditorState().read(function () {
-    var node = $getNodeByKey(key);
-    if (node === null) {
-      return false; // Node doesn't exist, so it's not selected.
-    }
-    return node.isSelected(); // Check if the node is selected.
-  });
-}
-function detectNodeSelection(editor) {
-  if (!editor) return false;
-  return editor.getEditorState().read(function () {
-    var _$getSelection;
-    return ((_$getSelection = $getSelection()) === null || _$getSelection === void 0 ? void 0 : _$getSelection.getNodes().length) === 1;
-  });
-}
-
-/**
- * A custom hook to manage the selection state of a specific node in a Lexical editor.
- *
- * This hook provides utilities to:
- * - Check if a node is selected.
- * - Update its selection state.
- * - Clear the selection.
- *
- * @param {NodeKey} key - The key of the node to track selection for.
- * @returns {[boolean, (selected: boolean) => void, () => void]} A tuple containing:
- * - `isSelected` (boolean): Whether the node is currently selected.
- * - `setSelected` (function): A function to set the selection state of the node.
- * - `clearSelected` (function): A function to clear the selection of the node.
- *
- */
-
-export function useLexicalNodeSelection(key) {
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  var lexicalEditor = editor.getLexicalEditor();
-
-  // State to track whether the node is currently selected.
-  var _useState = useState(function () {
-      return isNodeSelected(lexicalEditor, key);
-    }),
-    _useState2 = _slicedToArray(_useState, 2),
-    isSelected = _useState2[0],
-    setIsSelected = _useState2[1];
-  var _useState3 = useState(function () {
-      return detectNodeSelection(lexicalEditor);
-    }),
-    _useState4 = _slicedToArray(_useState3, 2),
-    isNodeSelection = _useState4[0],
-    setIsNodeSelection = _useState4[1];
-  useEffect(function () {
-    var isMounted = true;
-    if (!lexicalEditor) return;
-    var unregister = lexicalEditor.registerUpdateListener(function () {
-      if (isMounted) {
-        setIsSelected(isNodeSelected(lexicalEditor, key));
-        setIsNodeSelection(detectNodeSelection(lexicalEditor));
-      }
-    });
-    return function () {
-      isMounted = false; // Prevent updates after component unmount.
-      unregister();
-    };
-  }, [lexicalEditor, key]);
-  var setSelected = useCallback(function (selected) {
-    if (!lexicalEditor) return;
-    lexicalEditor.update(function () {
-      var _selection, _selection2;
-      var selection = $getSelection();
-      if (((_selection = selection) === null || _selection === void 0 ? void 0 : _selection.getNodes().length) === 1 && (_selection2 = selection) !== null && _selection2 !== void 0 && _selection2.getNodes().map(function (v) {
-        return v.getKey();
-      }).includes(key)) {
-        // If the node is already selected, we can just return.
-        return;
-      }
-      if (!$isNodeSelection(selection)) {
-        selection = $createNodeSelection();
-        $setSelection(selection);
-      }
-      if ($isNodeSelection(selection)) {
-        if (selected) {
-          selection.add(key);
-        } else {
-          selection.delete(key);
-        }
-      }
-    });
-  }, [lexicalEditor, key]);
-  var clearSelected = useCallback(function () {
-    if (!lexicalEditor) return;
-    lexicalEditor.update(function () {
-      var selection = $getSelection();
-      if ($isNodeSelection(selection)) {
-        selection.clear();
-      }
-    });
-  }, [lexicalEditor]);
-  return [isSelected, setSelected, clearSelected, isNodeSelection];
-}

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

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

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

@@ -1,19 +0,0 @@
-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/utils.d.ts

@@ -1,41 +0,0 @@
-import { EditorConfig, ElementNode, 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(): import("lexical").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?: ReturnType<LexicalEditor['getEditorState']>): 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?: ReturnType<LexicalEditor['getEditorState']>): LexicalNode | null;
-export declare function getKernelFromEditor(editor: LexicalEditor): IEditorKernel;
-export declare const EDITOR_THEME_KEY = "__editorId";
-export declare function generateEditorId(): string;
-export declare function registerEditorKernel(id: string, kernel: IEditorKernel): void;
-export declare function unregisterEditorKernel(id: string): void;
-export declare function getKernelFromEditorConfig(config: EditorConfig): IEditorKernel | null;
-/**
- *
- * @param nodeA
- * @param nodeB
- * @returns
- */
-export declare function compareNodeOrder(nodeA: LexicalNode, nodeB: LexicalNode): number;
-export declare function $closest(node: LexicalNode | ElementNode | null, test: (node: LexicalNode) => boolean): LexicalNode | null;
-export declare function $closestNodeType(node: LexicalNode | ElementNode | null, type: string | string[]): LexicalNode | null;
-export declare function moment(): Promise<unknown>;
-export declare function reconcileDecorator(activeEditor: LexicalEditor, key: NodeKey, decorator: unknown): void;