lexical 0.8.1 → 0.9.0

package/LexicalEditor.d.ts

@@ -194,63 +194,278 @@ export declare type SerializedEditor = {
     editorState: SerializedEditorState;
 };
 export declare function resetEditor(editor: LexicalEditor, prevRootElement: null | HTMLElement, nextRootElement: null | HTMLElement, pendingEditorState: EditorState): void;
+/**
+ * Creates a new LexicalEditor attached to a single contentEditable (provided in the config). This is
+ * the lowest-level initialization API for a LexicalEditor. If you're using React or another framework,
+ * consider using the appropriate abstractions, such as LexicalComposer
+ * @param editorConfig - the editor configuration.
+ * @returns a LexicalEditor instance
+ */
 export declare function createEditor(editorConfig?: CreateEditorArgs): LexicalEditor;
 export declare class LexicalEditor {
+    /** @internal */
     _headless: boolean;
+    /** @internal */
     _parentEditor: null | LexicalEditor;
+    /** @internal */
     _rootElement: null | HTMLElement;
+    /** @internal */
     _editorState: EditorState;
+    /** @internal */
     _pendingEditorState: null | EditorState;
+    /** @internal */
     _compositionKey: null | NodeKey;
+    /** @internal */
     _deferred: Array<() => void>;
+    /** @internal */
     _keyToDOMMap: Map<NodeKey, HTMLElement>;
+    /** @internal */
     _updates: Array<[() => void, EditorUpdateOptions | undefined]>;
+    /** @internal */
     _updating: boolean;
+    /** @internal */
     _listeners: Listeners;
+    /** @internal */
     _commands: Commands;
+    /** @internal */
     _nodes: RegisteredNodes;
+    /** @internal */
     _decorators: Record<NodeKey, unknown>;
+    /** @internal */
     _pendingDecorators: null | Record<NodeKey, unknown>;
+    /** @internal */
     _config: EditorConfig;
+    /** @internal */
     _dirtyType: 0 | 1 | 2;
+    /** @internal */
     _cloneNotNeeded: Set<NodeKey>;
+    /** @internal */
     _dirtyLeaves: Set<NodeKey>;
+    /** @internal */
     _dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
+    /** @internal */
     _normalizedNodes: Set<NodeKey>;
+    /** @internal */
     _updateTags: Set<string>;
+    /** @internal */
     _observer: null | MutationObserver;
+    /** @internal */
     _key: string;
+    /** @internal */
     _onError: ErrorHandler;
+    /** @internal */
     _htmlConversions: DOMConversionCache;
+    /** @internal */
     _window: null | Window;
+    /** @internal */
     _editable: boolean;
+    /** @internal */
     _blockCursorElement: null | HTMLDivElement;
+    /** @internal */
     constructor(editorState: EditorState, parentEditor: null | LexicalEditor, nodes: RegisteredNodes, config: EditorConfig, onError: ErrorHandler, htmlConversions: DOMConversionCache, editable: boolean);
+    /**
+     *
+     * @returns true if the editor is currently in "composition" mode due to receiving input
+     * through an IME, or 3P extension, for example. Returns false otherwise.
+     */
     isComposing(): boolean;
+    /**
+     * Registers a listener for Editor update event. Will trigger the provided callback
+     * each time the editor goes through an update (via {@link LexicalEditor.update}) until the
+     * teardown function is called.
+     *
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerUpdateListener(listener: UpdateListener): () => void;
+    /**
+     * Registers a listener for for when the editor changes between editable and non-editable states.
+     * Will trigger the provided callback each time the editor transitions between these states until the
+     * teardown function is called.
+     *
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerEditableListener(listener: EditableListener): () => void;
+    /**
+     * Registers a listener for when the editor's decorator object changes. The decorator object contains
+     * all DecoratorNode keys -> their decorated value. This is primarily used with external UI frameworks.
+     *
+     * Will trigger the provided callback each time the editor transitions between these states until the
+     * teardown function is called.
+     *
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerDecoratorListener<T>(listener: DecoratorListener<T>): () => void;
+    /**
+     * Registers a listener for when Lexical commits an update to the DOM and the text content of
+     * the editor changes from the previous state of the editor. If the text content is the
+     * same between updates, no notifications to the listeners will happen.
+     *
+     * Will trigger the provided callback each time the editor transitions between these states until the
+     * teardown function is called.
+     *
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerTextContentListener(listener: TextContentListener): () => void;
+    /**
+     * Registers a listener for when the editor's root DOM element (the content editable
+     * Lexical attaches to) changes. This is primarily used to attach event listeners to the root
+     *  element. The root listener function is executed directly upon registration and then on
+     * any subsequent update.
+     *
+     * Will trigger the provided callback each time the editor transitions between these states until the
+     * teardown function is called.
+     *
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerRootListener(listener: RootListener): () => void;
+    /**
+     * Registers a listener that will trigger anytime the provided command
+     * is dispatched, subject to priority. Listeners that run at a higher priority can "intercept"
+     * commands and prevent them from propagating to other handlers by returning true.
+     *
+     * Listeners registered at the same priority level will run deterministically in the order of registration.
+     *
+     * @param command - the command that will trigger the callback.
+     * @param listener - the function that will execute when the command is dispatched.
+     * @param priority - the relative priority of the listener. 0 | 1 | 2 | 3 | 4
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
+    /**
+     * Registers a listener that will run when a Lexical node of the provided class is
+     * mutated. The listener will receive a list of nodes along with the type of mutation
+     * that was performed on each: created, destroyed, or updated.
+     *
+     * One common use case for this is to attach DOM event listeners to the underlying DOM nodes as Lexical nodes are created.
+     * {@link LexicalEditor.getElementByKey} can be used for this.
+     *
+     * @param klass - The class of the node that you want to listen to mutations on.
+     * @param listener - The logic you want to run when the node is mutated.
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerMutationListener(klass: Klass<LexicalNode>, listener: MutationListener): () => void;
+    /** @internal */
     private registerNodeTransformToKlass;
+    /**
+     * Registers a listener that will run when a Lexical node of the provided class is
+     * marked dirty during an update. The listener will continue to run as long as the node
+     * is marked dirty. There are no guarantees around the order of transform execution!
+     *
+     * Watch out for infinite loops. See [Node Transforms](https://lexical.dev/docs/concepts/transforms)
+     * @param klass - The class of the node that you want to run transforms on.
+     * @param listener - The logic you want to run when the node is updated.
+     * @returns a teardown function that can be used to cleanup the listener.
+     */
     registerNodeTransform<T extends LexicalNode>(klass: Klass<T>, listener: Transform<T>): () => void;
+    /**
+     * Used to assert that certain nodes are registered, usually by plugins to ensure nodes that they
+     * depend on have been registered.
+     * @returns True if the editor has registered all of the provided node types, false otherwise.
+     */
     hasNodes<T extends Klass<LexicalNode>>(nodes: Array<T>): boolean;
+    /**
+     * Dispatches a command of the specified type with the specified payload.
+     * This triggers all command listeners (set by {@link LexicalEditor.registerCommand})
+     * for this type, passing them the provided payload.
+     * @param type - the type of command listeners to trigger.
+     * @param payload - the data to pass as an argument to the command listeners.
+     */
     dispatchCommand<TCommand extends LexicalCommand<unknown>>(type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+    /**
+     * Gets a map of all decorators in the editor.
+     * @returns A mapping of call decorator keys to their decorated content
+     */
     getDecorators<T>(): Record<NodeKey, T>;
+    /**
+     *
+     * @returns the current root element of the editor. If you want to register
+     * an event listener, do it via {@link LexicalEditor.registerRootListener}, since
+     * this reference may not be stable.
+     */
     getRootElement(): null | HTMLElement;
+    /**
+     * Gets the key of the editor
+     * @returns The editor key
+     */
     getKey(): string;
+    /**
+     * Imperatively set the root contenteditable element that Lexical listens
+     * for events on.
+     */
     setRootElement(nextRootElement: null | HTMLElement): void;
+    /**
+     * Gets the underlying HTMLElement associated with the LexicalNode for the given key.
+     * @returns the HTMLElement rendered by the LexicalNode associated with the key.
+     * @param key - the key of the LexicalNode.
+     */
     getElementByKey(key: NodeKey): HTMLElement | null;
+    /**
+     * Gets the active editor state.
+     * @returns The editor state
+     */
     getEditorState(): EditorState;
+    /**
+     * Imperatively set the EditorState. Triggers reconciliation like an update.
+     * @param editorState - the state to set the editor
+     * @param options - options for the update.
+     */
     setEditorState(editorState: EditorState, options?: EditorSetOptions): void;
+    /**
+     * Parses a SerializedEditorState (usually produced by {@link EditorState.toJSON}) and returns
+     * and EditorState object that can be, for example, passed to {@link LexicalEditor.setEditorState}. Typically,
+     * deserliazation from JSON stored in a database uses this method.
+     * @param maybeStringifiedEditorState
+     * @param updateFn
+     * @returns
+     */
     parseEditorState(maybeStringifiedEditorState: string | SerializedEditorState, updateFn?: () => void): EditorState;
+    /**
+     * Executes an update to the editor state. The updateFn callback is the ONLY place
+     * where Lexical editor state can be safely mutated.
+     * @param updateFn - A function that has access to writable editor state.
+     * @param options - A bag of options to control the behavior of the update.
+     * @param options.onUpdate - A function to run once the update is complete.
+     * Useful for synchronizing updates in some cases.
+     * @param options.skipTransforms - Setting this to true will suppress all node
+     * transforms for this update cycle.
+     * @param options.tag - A tag to identify this update, in an update listener, for instance.
+     * Some tags are reserved by the core and control update behavior in different ways.
+     * @param options.discrete - If true, prevents this update from being batched, forcing it to
+     * run synchronously.
+     */
     update(updateFn: () => void, options?: EditorUpdateOptions): void;
+    /**
+     * Focuses the editor
+     * @param callbackFn - A function to run after the editor is focused.
+     * @param options - A bag of options
+     * @param options.defaultSelection - Where to move selection when the editor is
+     * focused. Can be rootStart, rootEnd, or undefined. Defaults to rootEnd.
+     */
     focus(callbackFn?: () => void, options?: EditorFocusOptions): void;
+    /**
+     * Removes focus from the editor.
+     */
     blur(): void;
+    /**
+     * Returns true if the editor is editable, false otherwise.
+     * @returns True if the editor is editable, false otherwise.
+     */
     isEditable(): boolean;
+    /**
+     * Sets the editable property of the editor. When false, the
+     * editor will not listen for user events on the underling contenteditable.
+     * @param editable - the value to set the editable mode to.
+     */
     setEditable(editable: boolean): void;
+    /**
+     * Returns a JSON-serializable javascript object NOT a JSON string.
+     * You still must call JSON.stringify (or something else) to turn the
+     * state into a string you can transfer over the wire and store in a database.
+     *
+     * See {@link LexicalNode.exportJSON}
+     *
+     * @returns A JSON-serializable javascript object
+     */
     toJSON(): SerializedEditor;
 }
 export {};

package/LexicalEditorState.d.ts

@@ -6,11 +6,11 @@
  *
  */
 import type { LexicalEditor } from './LexicalEditor';
-import type { NodeMap } from './LexicalNode';
+import type { NodeMap, SerializedLexicalNode } from './LexicalNode';
 import type { GridSelection, NodeSelection, RangeSelection } from './LexicalSelection';
 import type { SerializedRootNode } from './nodes/LexicalRootNode';
-export interface SerializedEditorState {
-    root: SerializedRootNode;
+export interface SerializedEditorState<T extends SerializedLexicalNode = SerializedLexicalNode> {
+    root: SerializedRootNode<T>;
 }
 export declare function editorStateHasDirtySelection(editorState: EditorState, editor: LexicalEditor): boolean;
 export declare function cloneEditorState(current: EditorState): EditorState;

package/LexicalNode.d.ts

@@ -45,47 +45,288 @@ export declare class LexicalNode {
     __prev: null | NodeKey;
     /** @internal */
     __next: null | NodeKey;
+    /**
+     * Returns the string type of this node. Every node must
+     * implement this and it MUST BE UNIQUE amongst nodes registered
+     * on the editor.
+     *
+     */
     static getType(): string;
+    /**
+     * Clones this node, creating a new node with a different key
+     * and adding it to the EditorState (but not attaching it anywhere!). All nodes must
+     * implement this method.
+     *
+     */
     static clone(_data: unknown): LexicalNode;
     constructor(key?: NodeKey);
+    /**
+     * Returns the string type of this node.
+     */
     getType(): string;
+    /**
+     * Returns true if there is a path between this node and the RootNode, false otherwise.
+     * This is a way of determining if the node is "attached" EditorState. Unattached nodes
+     * won't be reconciled and will ultimatelt be cleaned up by the Lexical GC.
+     */
     isAttached(): boolean;
+    /**
+     * Returns true if this node is contained within the provided Selection., false otherwise.
+     * Relies on the algorithms implemented in {@link BaseSelection.getNodes} to determine
+     * what's included.
+     *
+     * @param selection - The selection that we want to determine if the node is in.
+     */
     isSelected(selection?: null | RangeSelection | NodeSelection | GridSelection): boolean;
+    /**
+     * Returns this nodes key.
+     */
     getKey(): NodeKey;
+    /**
+     * Returns the zero-based index of this node within the parent.
+     */
     getIndexWithinParent(): number;
+    /**
+     * Returns the parent of this node, or null if none is found.
+     */
     getParent<T extends ElementNode>(): T | null;
+    /**
+     * Returns the parent of this node, or throws if none is found.
+     */
     getParentOrThrow<T extends ElementNode>(): T;
+    /**
+     * Returns the highest (in the EditorState tree)
+     * non-root ancestor of this node, or null if none is found. See {@link lexical!$isRootOrShadowRoot}
+     * for more information on which Elements comprise "roots".
+     */
     getTopLevelElement(): ElementNode | this | null;
+    /**
+     * Returns the highest (in the EditorState tree)
+     * non-root ancestor of this node, or throws if none is found. See {@link lexical!$isRootOrShadowRoot}
+     * for more information on which Elements comprise "roots".
+     */
     getTopLevelElementOrThrow(): ElementNode | this;
+    /**
+     * Returns a list of the every ancestor of this node,
+     * all the way up to the RootNode.
+     *
+     */
     getParents(): Array<ElementNode>;
+    /**
+     * Returns a list of the keys of every ancestor of this node,
+     * all the way up to the RootNode.
+     *
+     */
     getParentKeys(): Array<NodeKey>;
+    /**
+     * Returns the "previous" siblings - that is, the node that comes
+     * before this one in the same parent.
+     *
+     */
     getPreviousSibling<T extends LexicalNode>(): T | null;
+    /**
+     * Returns the "previous" siblings - that is, the nodes that come between
+     * this one and the first child of it's parent, inclusive.
+     *
+     */
     getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+    /**
+     * Returns the "next" siblings - that is, the node that comes
+     * after this one in the same parent
+     *
+     */
     getNextSibling<T extends LexicalNode>(): T | null;
+    /**
+     * Returns all "next" siblings - that is, the nodes that come between this
+     * one and the last child of it's parent, inclusive.
+     *
+     */
     getNextSiblings<T extends LexicalNode>(): Array<T>;
+    /**
+     * Returns the closest common ancestor of this node and the provided one or null
+     * if one cannot be found.
+     *
+     * @param node - the other node to find the common ancestor of.
+     */
     getCommonAncestor<T extends ElementNode = ElementNode>(node: LexicalNode): T | null;
+    /**
+     * Returns true if the provided node is the exact same one as this node, from Lexical's perspective.
+     * Always use this instead of referential equality.
+     *
+     * @param object - the node to perform the equality comparison on.
+     */
     is(object: LexicalNode | null | undefined): boolean;
+    /**
+     * Returns true if this node logical precedes the target node in the editor state.
+     *
+     * @param targetNode - the node we're testing to see if it's after this one.
+     */
     isBefore(targetNode: LexicalNode): boolean;
+    /**
+     * Returns true if this node is the parent of the target node, false otherwise.
+     *
+     * @param targetNode - the would-be child node.
+     */
     isParentOf(targetNode: LexicalNode): boolean;
+    /**
+     * Returns a list of nodes that are between this node and
+     * the target node in the EditorState.
+     *
+     * @param targetNode - the node that marks the other end of the range of nodes to be returned.
+     */
     getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+    /**
+     * Returns true if this node has been marked dirty during this update cycle.
+     *
+     */
     isDirty(): boolean;
+    /**
+     * Returns the latest version of the node from the active EditorState.
+     * This is used to avoid getting values from stale node references.
+     *
+     */
     getLatest(): this;
+    /**
+     * Returns a mutable version of the node. Will throw an error if
+     * called outside of a Lexical Editor {@link LexicalEditor.update} callback.
+     *
+     */
     getWritable(): this;
+    /**
+     * Returns the text content of the node. Override this for
+     * custom nodes that should have a representation in plain text
+     * format (for copy + paste, for example)
+     *
+     */
     getTextContent(): string;
+    /**
+     * Returns the length of the string produced by calling getTextContent on this node.
+     *
+     */
     getTextContentSize(): number;
+    /**
+     * Called during the reconciliation process to determine which nodes
+     * to insert into the DOM for this Lexical Node.
+     *
+     * This method must return exactly one HTMLElement. Nested elements are not supported.
+     *
+     * Do not attempt to update the Lexical EditorState during this phase of the update lifecyle.
+     *
+     * @param _config - allows access to things like the EditorTheme (to apply classes) during reconciliation.
+     * @param _editor - allows access to the editor for context during reconciliation.
+     *
+     * */
     createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+    /**
+     * Called when a node changes and should update the DOM
+     * in whatever way is necessary to make it align with any changes that might
+     * have happened during the update.
+     *
+     * Returning "true" here will cause lexical to unmount and recreate the DOM node
+     * (by calling createDOM). You would need to do this if the element tag changes,
+     * for instance.
+     *
+     * */
     updateDOM(_prevNode: unknown, _dom: HTMLElement, _config: EditorConfig): boolean;
+    /**
+     * Controls how the this node is serialized to HTML. This is important for
+     * copy and paste between Lexical and non-Lexical editors, or Lexical editors with different namespaces,
+     * in which case the primary transfer format is HTML. It's also important if you're serializing
+     * to HTML for any other reason via {@link @lexical/html!$generateHtmlFromNodes}. You could
+     * also use this method to build your own HTML renderer.
+     *
+     * */
     exportDOM(editor: LexicalEditor): DOMExportOutput;
+    /**
+     * Controls how the this node is serialized to JSON. This is important for
+     * copy and paste between Lexical editors sharing the same namespace. It's also important
+     * if you're serializing to JSON for persistent storage somewhere.
+     * See [Serialization & Deserialization](https://lexical.dev/docs/concepts/serialization#lexical---html).
+     *
+     * */
     exportJSON(): SerializedLexicalNode;
+    /**
+     * Controls how the this node is deserialized from JSON. This is usually boilerplate,
+     * but provides an abstraction betweent he node implementation and serialized interfaec that can
+     * be important if you ever make breaking changes to a node schema (by adding or removing properties).
+     * See [Serialization & Deserialization](https://lexical.dev/docs/concepts/serialization#lexical---html).
+     *
+     * */
     static importJSON(_serializedNode: SerializedLexicalNode): LexicalNode;
+    /**
+     * @experimental
+     *
+     * Registers the returned function as a transform on the node during
+     * Editor initialization. Most such use cases should be addressed via
+     * the {@link LexicalEditor.registerNodeTransform} API.
+     *
+     * Experimental - use at your own risk.
+     */
+    static transform(): ((node: LexicalNode) => void) | null;
+    /**
+     * Removes this LexicalNode from the EditorState. If the node isn't re-inserted
+     * somewhere, the Lexical garbage collector will eventually clean it up.
+     *
+     * @param preserveEmptyParent - If falsy, the node's parent will be removed if
+     * it's empty after the removal operation. This is the default behavior, subject to
+     * other node heuristics such as {@link ElementNode#canBeEmpty}
+     * */
     remove(preserveEmptyParent?: boolean): void;
+    /**
+     * Replaces this LexicalNode with the provided node, optionally transferring the children
+     * of the replaced node to the replacing node.
+     *
+     * @param replaceWith - The node to replace this one with.
+     * @param includeChildren - Whether or not to transfer the children of this node to the replacing node.
+     * */
     replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+    /**
+     * Inserts a node after this LexicalNode (as the next sibling).
+     *
+     * @param nodeToInsert - The node to insert after this one.
+     * @param restoreSelection - Whether or not to attempt to resolve the
+     * selection to the appropriate place after the operation is complete.
+     * */
     insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+    /**
+     * Inserts a node before this LexicalNode (as the previous sibling).
+     *
+     * @param nodeToInsert - The node to insert after this one.
+     * @param restoreSelection - Whether or not to attempt to resolve the
+     * selection to the appropriate place after the operation is complete.
+     * */
     insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+    /**
+     * Whether or not this node has a required parent. Used during copy + paste operations
+     * to normalize nodes that would otherwise be orphaned. For example, ListItemNodes without
+     * a ListNode parent or TextNodes with a ParagraphNode parent.
+     *
+     * */
     isParentRequired(): boolean;
+    /**
+     * The creation logic for any required parent. Should be implemented if {@link isParentRequired} returns true.
+     *
+     * */
     createParentElementNode(): ElementNode;
+    /**
+     * Moves selection to the previous sibling of this node, at the specified offsets.
+     *
+     * @param anchorOffset - The anchor offset for selection.
+     * @param focusOffset -  The focus offset for selection
+     * */
     selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+    /**
+     * Moves selection to the next sibling of this node, at the specified offsets.
+     *
+     * @param anchorOffset - The anchor offset for selection.
+     * @param focusOffset -  The focus offset for selection
+     * */
     selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+    /**
+     * Marks a node dirty, triggering transforms and
+     * forcing it to be reconciled during the update cycle.
+     *
+     * */
     markDirty(): void;
 }
 export {};

package/LexicalUtils.d.ts

@@ -110,3 +110,5 @@ export declare function removeDOMBlockCursorElement(blockCursorElement: HTMLElem
 export declare function updateDOMBlockCursorElement(editor: LexicalEditor, rootElement: HTMLElement, nextSelection: null | RangeSelection | NodeSelection | GridSelection): void;
 export declare function getDOMSelection(targetWindow: null | Window): null | Selection;
 export declare function $splitNode(node: ElementNode, offset: number): [ElementNode | null, ElementNode];
+export declare function $findMatchingParent(startingNode: LexicalNode, findFn: (node: LexicalNode) => boolean): LexicalNode | null;
+export declare function $getChildrenRecursively(node: LexicalNode): Array<LexicalNode>;

package/index.d.ts

@@ -7,7 +7,7 @@
  *
  */
 export type { PasteCommandType } from './LexicalCommands';
-export type { CommandListenerPriority, CommandPayloadType, CreateEditorArgs, EditableListener, EditorConfig, EditorThemeClasses, Klass, LexicalCommand, LexicalEditor, MutationListener, NodeMutation, SerializedEditor, Spread, } from './LexicalEditor';
+export type { CommandListener, CommandListenerPriority, CommandPayloadType, CreateEditorArgs, EditableListener, EditorConfig, EditorThemeClasses, Klass, LexicalCommand, LexicalEditor, MutationListener, NodeMutation, SerializedEditor, Spread, } from './LexicalEditor';
 export type { EditorState, SerializedEditorState } from './LexicalEditorState';
 export type { DOMChildConversion, DOMConversion, DOMConversionFn, DOMConversionMap, DOMConversionOutput, DOMExportOutput, LexicalNode, NodeKey, NodeMap, SerializedLexicalNode, } from './LexicalNode';
 export type { BaseSelection, ElementPointType as ElementPoint, GridSelection, GridSelectionShape, NodeSelection, Point, RangeSelection, TextPointType as TextPoint, } from './LexicalSelection';

package/nodes/LexicalElementNode.d.ts

@@ -10,8 +10,8 @@ import type { GridSelection, NodeSelection, RangeSelection } from '../LexicalSel
 import type { Spread } from 'lexical';
 import { TextNode } from '../';
 import { LexicalNode } from '../LexicalNode';
-export declare type SerializedElementNode = Spread<{
-    children: Array<SerializedLexicalNode>;
+export declare type SerializedElementNode<T extends SerializedLexicalNode = SerializedLexicalNode> = Spread<{
+    children: Array<T>;
     direction: 'ltr' | 'rtl' | null;
     format: ElementFormatType;
     indent: number;
@@ -51,6 +51,7 @@ export declare class ElementNode extends LexicalNode {
     getLastChildOrThrow<T extends LexicalNode>(): T;
     getChildAtIndex<T extends LexicalNode>(index: number): null | T;
     getTextContent(): string;
+    getTextContentSize(): number;
     getDirection(): 'ltr' | 'rtl' | null;
     hasFormat(type: ElementFormatType): boolean;
     select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;

package/nodes/LexicalGridCellNode.d.ts

@@ -14,7 +14,10 @@ export declare type SerializedGridCellNode = Spread<{
 export declare class DEPRECATED_GridCellNode extends ElementNode {
     /** @internal */
     __colSpan: number;
+    __rowSpan: number;
     constructor(colSpan: number, key?: NodeKey);
     exportJSON(): SerializedGridCellNode;
+    setColSpan(colSpan: number): this;
+    setRowSpan(rowSpan: number): this;
 }
 export declare function DEPRECATED_$isGridCellNode(node: DEPRECATED_GridCellNode | LexicalNode | null | undefined): node is DEPRECATED_GridCellNode;

package/nodes/LexicalRootNode.d.ts

@@ -5,10 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { LexicalNode } from '../LexicalNode';
+import type { LexicalNode, SerializedLexicalNode } from '../LexicalNode';
 import type { SerializedElementNode } from './LexicalElementNode';
 import { ElementNode } from './LexicalElementNode';
-export declare type SerializedRootNode = SerializedElementNode;
+export declare type SerializedRootNode<T extends SerializedLexicalNode = SerializedLexicalNode> = SerializedElementNode<T>;
 /** @noInheritDoc */
 export declare class RootNode extends ElementNode {
     /** @internal */

package/package.json

@@ -9,7 +9,7 @@
     "rich-text"
   ],
   "license": "MIT",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "main": "Lexical.js",
   "repository": {
     "type": "git",