@lobehub/editor 4.5.0 → 4.6.0

package/es/editor-kernel/lexical/nodes/LexicalParagraphNode.d.ts

@@ -1,39 +0,0 @@
-/**
- * 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 type { EditorConfig, KlassConstructor, LexicalEditor, Spread } from '../LexicalEditor';
-import type { DOMConversionMap, DOMExportOutput, LexicalNode } from '../LexicalNode';
-import type { RangeSelection } from '../LexicalSelection';
-import type { SerializedElementNode } from './LexicalElementNode';
-import { ElementNode } from './LexicalElementNode';
-
-export type SerializedParagraphNode = Spread<
-  {
-    textFormat: number;
-    textStyle: string;
-  },
-  SerializedElementNode
->;
-/** @noInheritDoc */
-export declare class ParagraphNode extends ElementNode {
-  /** @internal */
-  ['constructor']: KlassConstructor<typeof ParagraphNode>;
-  static getType(): string;
-  static clone(node: ParagraphNode): ParagraphNode;
-  createDOM(config: EditorConfig): HTMLElement;
-  updateDOM(prevNode: ParagraphNode, dom: HTMLElement, config: EditorConfig): boolean;
-  static importDOM(): DOMConversionMap | null;
-  exportDOM(editor: LexicalEditor): DOMExportOutput;
-  static importJSON(serializedNode: SerializedParagraphNode): ParagraphNode;
-  exportJSON(): SerializedParagraphNode;
-  insertNewAfter(rangeSelection: RangeSelection, restoreSelection: boolean): ParagraphNode;
-  collapseAtStart(): boolean;
-}
-export declare function $createParagraphNode(): ParagraphNode;
-export declare function $isParagraphNode(
-  node: LexicalNode | null | undefined,
-): node is ParagraphNode;

package/es/editor-kernel/lexical/nodes/LexicalRootNode.d.ts

@@ -1,35 +0,0 @@
-/**
- * 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 type { LexicalNode, SerializedLexicalNode } from '../LexicalNode';
-import type { SerializedElementNode } from './LexicalElementNode';
-import { ElementNode } from './LexicalElementNode';
-
-export type SerializedRootNode<T extends SerializedLexicalNode = SerializedLexicalNode> =
-  SerializedElementNode<T>;
-/** @noInheritDoc */
-export declare class RootNode extends ElementNode {
-  /** @internal */
-  __cachedText: null | string;
-  static getType(): string;
-  static clone(): RootNode;
-  constructor();
-  getTopLevelElementOrThrow(): never;
-  getTextContent(): string;
-  remove(): never;
-  replace<N = LexicalNode>(node: N): never;
-  insertBefore(nodeToInsert: LexicalNode): LexicalNode;
-  insertAfter(nodeToInsert: LexicalNode): LexicalNode;
-  updateDOM(prevNode: this, dom: HTMLElement): false;
-  splice(start: number, deleteCount: number, nodesToInsert: LexicalNode[]): this;
-  static importJSON(serializedNode: SerializedRootNode): RootNode;
-  collapseAtStart(): true;
-}
-export declare function $createRootNode(): RootNode;
-export declare function $isRootNode(
-  node: RootNode | LexicalNode | null | undefined,
-): node is RootNode;

package/es/editor-kernel/lexical/nodes/LexicalTabNode.d.ts

@@ -1,30 +0,0 @@
-/**
- * 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 { EditorConfig } from '../LexicalEditor';
-import type { DOMConversionMap, NodeKey } from '../LexicalNode';
-import { LexicalNode } from '../LexicalNode';
-import { SerializedTextNode, TextDetailType, TextModeType, TextNode } from './LexicalTextNode';
-
-export type SerializedTabNode = SerializedTextNode;
-/** @noInheritDoc */
-export declare class TabNode extends TextNode {
-  static getType(): string;
-  static clone(node: TabNode): TabNode;
-  constructor(key?: NodeKey);
-  static importDOM(): DOMConversionMap | null;
-  createDOM(config: EditorConfig): HTMLElement;
-  static importJSON(serializedTabNode: SerializedTabNode): TabNode;
-  setTextContent(text: string): this;
-  spliceText(offset: number, delCount: number, newText: string, moveSelection?: boolean): TextNode;
-  setDetail(detail: TextDetailType | number): this;
-  setMode(type: TextModeType): this;
-  canInsertTextBefore(): boolean;
-  canInsertTextAfter(): boolean;
-}
-export declare function $createTabNode(): TabNode;
-export declare function $isTabNode(node: LexicalNode | null | undefined): node is TabNode;

package/es/editor-kernel/lexical/nodes/LexicalTextNode.d.ts

@@ -1,311 +0,0 @@
-/**
- * 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 type { EditorConfig, KlassConstructor, LexicalEditor, Spread } from '../LexicalEditor';
-import type {
-  DOMConversionMap,
-  DOMExportOutput,
-  LexicalUpdateJSON,
-  NodeKey,
-  SerializedLexicalNode,
-} from '../LexicalNode';
-import { LexicalNode } from '../LexicalNode';
-import type { BaseSelection, RangeSelection } from '../LexicalSelection';
-import type { ElementNode } from './LexicalElementNode';
-
-export type SerializedTextNode = Spread<
-  {
-    detail: number;
-    format: number;
-    mode: TextModeType;
-    style: string;
-    text: string;
-  },
-  SerializedLexicalNode
->;
-export type TextDetailType = 'directionless' | 'unmergable';
-export type TextFormatType =
-  | 'bold'
-  | 'underline'
-  | 'strikethrough'
-  | 'italic'
-  | 'highlight'
-  | 'code'
-  | 'subscript'
-  | 'superscript'
-  | 'lowercase'
-  | 'uppercase'
-  | 'capitalize';
-export type TextModeType = 'normal' | 'token' | 'segmented';
-export type TextMark = {
-  end: null | number;
-  id: string;
-  start: null | number;
-};
-export type TextMarks = Array<TextMark>;
-export interface TextNode {
-  getTopLevelElement(): ElementNode | null;
-  getTopLevelElementOrThrow(): ElementNode;
-}
-/** @noInheritDoc */
-export declare class TextNode extends LexicalNode {
-  /** @internal */
-  ['constructor']: KlassConstructor<typeof TextNode>;
-  __text: string;
-  /** @internal */
-  __format: number;
-  /** @internal */
-  __style: string;
-  /** @internal */
-  __mode: 0 | 1 | 2 | 3;
-  /** @internal */
-  __detail: number;
-  static getType(): string;
-  static clone(node: TextNode): TextNode;
-  afterCloneFrom(prevNode: this): void;
-  constructor(text?: string, key?: NodeKey);
-  /**
-   * Returns a 32-bit integer that represents the TextFormatTypes currently applied to the
-   * TextNode. You probably don't want to use this method directly - consider using TextNode.hasFormat instead.
-   *
-   * @returns a number representing the format of the text node.
-   */
-  getFormat(): number;
-  /**
-   * Returns a 32-bit integer that represents the TextDetailTypes currently applied to the
-   * TextNode. You probably don't want to use this method directly - consider using TextNode.isDirectionless
-   * or TextNode.isUnmergeable instead.
-   *
-   * @returns a number representing the detail of the text node.
-   */
-  getDetail(): number;
-  /**
-   * Returns the mode (TextModeType) of the TextNode, which may be "normal", "token", or "segmented"
-   *
-   * @returns TextModeType.
-   */
-  getMode(): TextModeType;
-  /**
-   * Returns the styles currently applied to the node. This is analogous to CSSText in the DOM.
-   *
-   * @returns CSSText-like string of styles applied to the underlying DOM node.
-   */
-  getStyle(): string;
-  /**
-   * Returns whether or not the node is in "token" mode. TextNodes in token mode can be navigated through character-by-character
-   * with a RangeSelection, but are deleted as a single entity (not individually by character).
-   *
-   * @returns true if the node is in token mode, false otherwise.
-   */
-  isToken(): boolean;
-  /**
-   *
-   * @returns true if Lexical detects that an IME or other 3rd-party script is attempting to
-   * mutate the TextNode, false otherwise.
-   */
-  isComposing(): boolean;
-  /**
-   * Returns whether or not the node is in "segmented" mode. TextNodes in segmented mode can be navigated through character-by-character
-   * with a RangeSelection, but are deleted in space-delimited "segments".
-   *
-   * @returns true if the node is in segmented mode, false otherwise.
-   */
-  isSegmented(): boolean;
-  /**
-   * Returns whether or not the node is "directionless". Directionless nodes don't respect changes between RTL and LTR modes.
-   *
-   * @returns true if the node is directionless, false otherwise.
-   */
-  isDirectionless(): boolean;
-  /**
-   * Returns whether or not the node is unmergeable. In some scenarios, Lexical tries to merge
-   * adjacent TextNodes into a single TextNode. If a TextNode is unmergeable, this won't happen.
-   *
-   * @returns true if the node is unmergeable, false otherwise.
-   */
-  isUnmergeable(): boolean;
-  /**
-   * Returns whether or not the node has the provided format applied. Use this with the human-readable TextFormatType
-   * string values to get the format of a TextNode.
-   *
-   * @param type - the TextFormatType to check for.
-   *
-   * @returns true if the node has the provided format, false otherwise.
-   */
-  hasFormat(type: TextFormatType): boolean;
-  /**
-   * Returns whether or not the node is simple text. Simple text is defined as a TextNode that has the string type "text"
-   * (i.e., not a subclass) and has no mode applied to it (i.e., not segmented or token).
-   *
-   * @returns true if the node is simple text, false otherwise.
-   */
-  isSimpleText(): boolean;
-  /**
-   * Returns the text content of the node as a string.
-   *
-   * @returns a string representing the text content of the node.
-   */
-  getTextContent(): string;
-  /**
-   * Returns the format flags applied to the node as a 32-bit integer.
-   *
-   * @returns a number representing the TextFormatTypes applied to the node.
-   */
-  getFormatFlags(type: TextFormatType, alignWithFormat: null | number): number;
-  /**
-   *
-   * @returns true if the text node supports font styling, false otherwise.
-   */
-  canHaveFormat(): boolean;
-  /**
-   * @returns true if the text node is inline, false otherwise.
-   */
-  isInline(): true;
-  createDOM(config: EditorConfig, editor?: LexicalEditor): HTMLElement;
-  updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): boolean;
-  static importDOM(): DOMConversionMap | null;
-  static importJSON(serializedNode: SerializedTextNode): TextNode;
-  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTextNode>): this;
-  exportDOM(editor: LexicalEditor): DOMExportOutput;
-  exportJSON(): SerializedTextNode;
-  selectionTransform(prevSelection: null | BaseSelection, nextSelection: RangeSelection): void;
-  /**
-   * Sets the node format to the provided TextFormatType or 32-bit integer. Note that the TextFormatType
-   * version of the argument can only specify one format and doing so will remove all other formats that
-   * may be applied to the node. For toggling behavior, consider using {@link TextNode.toggleFormat}
-   *
-   * @param format - TextFormatType or 32-bit integer representing the node format.
-   *
-   * @returns this TextNode.
-   * // TODO 0.12 This should just be a `string`.
-   */
-  setFormat(format: TextFormatType | number): this;
-  /**
-   * Sets the node detail to the provided TextDetailType or 32-bit integer. Note that the TextDetailType
-   * version of the argument can only specify one detail value and doing so will remove all other detail values that
-   * may be applied to the node. For toggling behavior, consider using {@link TextNode.toggleDirectionless}
-   * or {@link TextNode.toggleUnmergeable}
-   *
-   * @param detail - TextDetailType or 32-bit integer representing the node detail.
-   *
-   * @returns this TextNode.
-   * // TODO 0.12 This should just be a `string`.
-   */
-  setDetail(detail: TextDetailType | number): this;
-  /**
-   * Sets the node style to the provided CSSText-like string. Set this property as you
-   * would an HTMLElement style attribute to apply inline styles to the underlying DOM Element.
-   *
-   * @param style - CSSText to be applied to the underlying HTMLElement.
-   *
-   * @returns this TextNode.
-   */
-  setStyle(style: string): this;
-  /**
-   * Applies the provided format to this TextNode if it's not present. Removes it if it's present.
-   * The subscript and superscript formats are mutually exclusive.
-   * Prefer using this method to turn specific formats on and off.
-   *
-   * @param type - TextFormatType to toggle.
-   *
-   * @returns this TextNode.
-   */
-  toggleFormat(type: TextFormatType): this;
-  /**
-   * Toggles the directionless detail value of the node. Prefer using this method over setDetail.
-   *
-   * @returns this TextNode.
-   */
-  toggleDirectionless(): this;
-  /**
-   * Toggles the unmergeable detail value of the node. Prefer using this method over setDetail.
-   *
-   * @returns this TextNode.
-   */
-  toggleUnmergeable(): this;
-  /**
-   * Sets the mode of the node.
-   *
-   * @returns this TextNode.
-   */
-  setMode(type: TextModeType): this;
-  /**
-   * Sets the text content of the node.
-   *
-   * @param text - the string to set as the text value of the node.
-   *
-   * @returns this TextNode.
-   */
-  setTextContent(text: string): this;
-  /**
-   * Sets the current Lexical selection to be a RangeSelection with anchor and focus on this TextNode at the provided offsets.
-   *
-   * @param _anchorOffset - the offset at which the Selection anchor will be placed.
-   * @param _focusOffset - the offset at which the Selection focus will be placed.
-   *
-   * @returns the new RangeSelection.
-   */
-  select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
-  selectStart(): RangeSelection;
-  selectEnd(): RangeSelection;
-  /**
-   * Inserts the provided text into this TextNode at the provided offset, deleting the number of characters
-   * specified. Can optionally calculate a new selection after the operation is complete.
-   *
-   * @param offset - the offset at which the splice operation should begin.
-   * @param delCount - the number of characters to delete, starting from the offset.
-   * @param newText - the text to insert into the TextNode at the offset.
-   * @param moveSelection - optional, whether or not to move selection to the end of the inserted substring.
-   *
-   * @returns this TextNode.
-   */
-  spliceText(offset: number, delCount: number, newText: string, moveSelection?: boolean): TextNode;
-  /**
-   * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
-   * when a user event would cause text to be inserted before them in the editor. If true, Lexical will attempt
-   * to insert text into this node. If false, it will insert the text in a new sibling node.
-   *
-   * @returns true if text can be inserted before the node, false otherwise.
-   */
-  canInsertTextBefore(): boolean;
-  /**
-   * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
-   * when a user event would cause text to be inserted after them in the editor. If true, Lexical will attempt
-   * to insert text into this node. If false, it will insert the text in a new sibling node.
-   *
-   * @returns true if text can be inserted after the node, false otherwise.
-   */
-  canInsertTextAfter(): boolean;
-  /**
-   * Splits this TextNode at the provided character offsets, forming new TextNodes from the substrings
-   * formed by the split, and inserting those new TextNodes into the editor, replacing the one that was split.
-   *
-   * @param splitOffsets - rest param of the text content character offsets at which this node should be split.
-   *
-   * @returns an Array containing the newly-created TextNodes.
-   */
-  splitText(...splitOffsets: Array<number>): Array<TextNode>;
-  /**
-   * Merges the target TextNode into this TextNode, removing the target node.
-   *
-   * @param target - the TextNode to merge into this one.
-   *
-   * @returns this TextNode.
-   */
-  mergeWithSibling(target: TextNode): TextNode;
-  /**
-   * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
-   * when used with the registerLexicalTextEntity function. If you're using registerLexicalTextEntity, the
-   * node class that you create and replace matched text with should return true from this method.
-   *
-   * @returns true if the node is to be treated as a "text entity", false otherwise.
-   */
-  isTextEntity(): boolean;
-}
-export declare function findParentPreDOMNode(node: Node): any;
-export declare function $createTextNode(text?: string): TextNode;
-export declare function $isTextNode(node: LexicalNode | null | undefined): node is TextNode;

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

@@ -1,21 +0,0 @@
-import EventEmitter from 'eventemitter3';
-import type { IEditorKernel } from "../types/kernel";
-export declare abstract class KernelPlugin extends EventEmitter {
-    protected clears: Array<() => void>;
-    protected registeredDecorators: Set<string>;
-    protected register(clear: () => void): void;
-    protected registerClears(...clears: Array<() => void>): void;
-    /**
-     * Register a decorator and track it for cleanup
-     */
-    protected registerDecorator(kernel: IEditorKernel, name: string, decorator: (node: any, editor: any) => any): void;
-    /**
-     * Unregister a specific decorator
-     */
-    protected unregisterDecorator(kernel: IEditorKernel, name: string): boolean;
-    /**
-     * Get all decorator names registered by this plugin
-     */
-    getRegisteredDecorators(): string[];
-    destroy(): void;
-}

package/es/editor-kernel/plugin.js

@@ -1,90 +0,0 @@
-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", []);
-    _defineProperty(_assertThisInitialized(_this), "registeredDecorators", new Set());
-    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);
-      });
-    }
-
-    /**
-     * Register a decorator and track it for cleanup
-     */
-  }, {
-    key: "registerDecorator",
-    value: function registerDecorator(kernel, name, decorator) {
-      kernel.registerDecorator(name, decorator);
-      this.registeredDecorators.add(name);
-    }
-
-    /**
-     * Unregister a specific decorator
-     */
-  }, {
-    key: "unregisterDecorator",
-    value: function unregisterDecorator(kernel, name) {
-      var result = kernel.unregisterDecorator(name);
-      if (result) {
-        this.registeredDecorators.delete(name);
-      }
-      return result;
-    }
-
-    /**
-     * Get all decorator names registered by this plugin
-     */
-  }, {
-    key: "getRegisteredDecorators",
-    value: function getRegisteredDecorators() {
-      return Array.from(this.registeredDecorators);
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.clears.forEach(function (clear) {
-        return clear();
-      });
-      // Note: Decorators will be cleaned up when kernel.destroy() is called
-      // Individual decorator cleanup should be handled by the kernel itself
-      this.registeredDecorators.clear();
-    }
-  }]);
-  return KernelPlugin;
-}(EventEmitter);

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

@@ -1,13 +0,0 @@
-/**
- * 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 type { JSX } from 'react';
-export type LexicalErrorBoundaryProps = {
-    children: JSX.Element;
-    onError: (error: unknown) => void;
-};
-export declare function LexicalErrorBoundary({ children, onError, }: LexicalErrorBoundaryProps): JSX.Element;

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

@@ -1,26 +0,0 @@
-/**
- * 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 { ErrorBoundary as ReactErrorBoundary } from 'react-error-boundary';
-import { jsx as _jsx } from "react/jsx-runtime";
-export function LexicalErrorBoundary(_ref) {
-  var children = _ref.children,
-    onError = _ref.onError;
-  return /*#__PURE__*/_jsx(ReactErrorBoundary, {
-    fallback: /*#__PURE__*/_jsx("div", {
-      style: {
-        border: '1px solid #f00',
-        color: '#f00',
-        padding: '8px'
-      },
-      children: "An error was thrown."
-    }),
-    onError: onError,
-    children: children
-  });
-}

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

@@ -1,6 +0,0 @@
-import { type FC, type PropsWithChildren } from 'react';
-interface PortalAnchorProps {
-    anchorElem?: HTMLElement;
-}
-declare const PortalAnchor: FC<PropsWithChildren<PortalAnchorProps>>;
-export default PortalAnchor;

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

@@ -1,12 +0,0 @@
-'use client';
-
-import { createPortal } from 'react-dom';
-import { useAnchor } from "./useAnchor";
-var PortalAnchor = function PortalAnchor(_ref) {
-  var children = _ref.children;
-  var targetElement = useAnchor();
-  if (!targetElement) return null;
-  return /*#__PURE__*/createPortal(children, targetElement);
-};
-PortalAnchor.displayName = 'PortalAnchor';
-export default PortalAnchor;

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

@@ -1,11 +0,0 @@
-import { LexicalEditor, LexicalNode } from 'lexical';
-import React from 'react';
-export interface PortalContainerProps {
-    children: React.ReactNode;
-    className?: string;
-    editor: LexicalEditor;
-    node: LexicalNode;
-    style?: React.CSSProperties;
-}
-export declare const LexicalPortalContainer: React.ForwardRefExoticComponent<PortalContainerProps & React.RefAttributes<HTMLDivElement | null>>;
-export default LexicalPortalContainer;

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

@@ -1,32 +0,0 @@
-import React, { forwardRef, useEffect, useImperativeHandle, useRef } from 'react';
-import { jsx as _jsx } from "react/jsx-runtime";
-export var LexicalPortalContainer = /*#__PURE__*/forwardRef(function (_ref, ref) {
-  var editor = _ref.editor,
-    node = _ref.node,
-    children = _ref.children;
-  var divRef = useRef(null);
-  useImperativeHandle(ref, function () {
-    return divRef.current;
-  }, []);
-  useEffect(function () {
-    return function () {
-      if (divRef.current) {
-        // @ts-expect-error not error
-        delete divRef.current["__lexicalKey_".concat(editor._key)];
-      }
-    };
-  }, [editor, node]);
-  return /*#__PURE__*/_jsx("div", {
-    ref: function ref(dom) {
-      divRef.current = dom;
-      if (dom) {
-        var prop = "__lexicalKey_".concat(editor._key);
-        // @ts-expect-error not error
-        dom[prop] = node.getKey();
-      }
-    },
-    children: children
-  });
-});
-LexicalPortalContainer.displayName = 'LexicalPortalContainer';
-export default LexicalPortalContainer;

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

@@ -1,5 +0,0 @@
-export { LexicalErrorBoundary } from './LexicalErrorBoundary';
-export { LexicalPortalContainer } from './PortalContainer';
-export { useLexicalComposerContext } from './react-context';
-export { ReactEditor } from './react-editor';
-export { useLexicalEditor } from './useLexicalEditor';

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

@@ -1,5 +0,0 @@
-export { LexicalErrorBoundary } from "./LexicalErrorBoundary";
-export { LexicalPortalContainer } from "./PortalContainer";
-export { useLexicalComposerContext } from "./react-context";
-export { ReactEditor } from "./react-editor";
-export { useLexicalEditor } from "./useLexicalEditor";

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

@@ -1,10 +0,0 @@
-import type { EditorThemeClasses } from 'lexical';
-import { type Context } from 'react';
-import { IEditor } from "../../types";
-export type LexicalComposerContextType = {
-    getTheme: () => EditorThemeClasses | null | undefined;
-};
-export type LexicalComposerContextWithEditor = [IEditor, LexicalComposerContextType];
-export declare const LexicalComposerContext: Context<LexicalComposerContextWithEditor | null | undefined>;
-export declare function createLexicalComposerContext(parent: LexicalComposerContextWithEditor | null | undefined, theme: EditorThemeClasses | null | undefined): LexicalComposerContextType;
-export declare function useLexicalComposerContext(): LexicalComposerContextWithEditor;