lexical 0.4.0 → 0.5.0

package/LexicalCommands.d.ts

@@ -13,7 +13,7 @@ export declare const DELETE_CHARACTER_COMMAND: LexicalCommand<boolean>;
 export declare const INSERT_LINE_BREAK_COMMAND: LexicalCommand<boolean>;
 export declare const INSERT_PARAGRAPH_COMMAND: LexicalCommand<void>;
 export declare const CONTROLLED_TEXT_INSERTION_COMMAND: LexicalCommand<InputEvent | string>;
-export declare const PASTE_COMMAND: LexicalCommand<ClipboardEvent | InputEvent>;
+export declare const PASTE_COMMAND: LexicalCommand<ClipboardEvent | InputEvent | KeyboardEvent>;
 export declare const REMOVE_TEXT_COMMAND: LexicalCommand<void>;
 export declare const DELETE_WORD_COMMAND: LexicalCommand<boolean>;
 export declare const DELETE_LINE_COMMAND: LexicalCommand<boolean>;

package/LexicalConstants.d.ts

@@ -15,7 +15,6 @@ export declare const FULL_RECONCILE = 2;
 export declare const IS_NORMAL = 0;
 export declare const IS_TOKEN = 1;
 export declare const IS_SEGMENTED = 2;
-export declare const IS_INERT = 3;
 export declare const IS_BOLD = 1;
 export declare const IS_ITALIC: number;
 export declare const IS_STRIKETHROUGH: number;
@@ -40,5 +39,5 @@ export declare const TEXT_TYPE_TO_FORMAT: Record<TextFormatType | string, number
 export declare const DETAIL_TYPE_TO_DETAIL: Record<TextDetailType | string, number>;
 export declare const ELEMENT_TYPE_TO_FORMAT: Record<Exclude<ElementFormatType, ''>, number>;
 export declare const ELEMENT_FORMAT_TO_TYPE: Record<number, ElementFormatType>;
-export declare const TEXT_MODE_TO_TYPE: Record<TextModeType, 0 | 1 | 2 | 3>;
+export declare const TEXT_MODE_TO_TYPE: Record<TextModeType, 0 | 1 | 2>;
 export declare const TEXT_TYPE_TO_MODE: Record<number, TextModeType>;

package/LexicalEditor.d.ts

@@ -70,9 +70,20 @@ export declare type EditorThemeClasses = {
     root?: EditorThemeClassName;
     rtl?: EditorThemeClassName;
     table?: EditorThemeClassName;
+    tableAddColumns?: EditorThemeClassName;
+    tableAddRows?: EditorThemeClassName;
+    tableCellActionButton?: EditorThemeClassName;
+    tableCellActionButtonContainer?: EditorThemeClassName;
+    tableCellPrimarySelected?: EditorThemeClassName;
+    tableCellSelected?: EditorThemeClassName;
     tableCell?: EditorThemeClassName;
+    tableCellEditing?: EditorThemeClassName;
     tableCellHeader?: EditorThemeClassName;
+    tableCellResizer?: EditorThemeClassName;
+    tableCellSortedIndicator?: EditorThemeClassName;
+    tableResizeRuler?: EditorThemeClassName;
     tableRow?: EditorThemeClassName;
+    tableSelected?: EditorThemeClassName;
     text?: TextNodeThemeClasses;
     embedBlock?: {
         base?: EditorThemeClassName;

package/LexicalNode.d.ts

@@ -19,7 +19,7 @@ export declare type DOMConversion<T extends HTMLElement = HTMLElement> = {
     conversion: DOMConversionFn<T>;
     priority: 0 | 1 | 2 | 3 | 4;
 };
-export declare type DOMConversionFn<T extends HTMLElement = HTMLElement> = (element: T, parent?: Node) => DOMConversionOutput | null;
+export declare type DOMConversionFn<T extends HTMLElement = HTMLElement> = (element: T, parent?: Node, preformatted?: boolean) => DOMConversionOutput | null;
 export declare type DOMChildConversion = (lexicalNode: LexicalNode, parentLexicalNode: LexicalNode | null | undefined) => LexicalNode | null | undefined;
 export declare type DOMConversionMap<T extends HTMLElement = HTMLElement> = Record<NodeName, (node: T) => DOMConversion<T> | null>;
 declare type NodeName = string;
@@ -27,6 +27,7 @@ export declare type DOMConversionOutput = {
     after?: (childLexicalNodes: Array<LexicalNode>) => Array<LexicalNode>;
     forChild?: DOMChildConversion;
     node: LexicalNode | null;
+    preformatted?: boolean;
 };
 export declare type DOMExportOutput = {
     after?: (generatedElement: HTMLElement | null | undefined) => HTMLElement | null | undefined;
@@ -67,8 +68,8 @@ export declare class LexicalNode {
     isDirty(): boolean;
     getLatest(): this;
     getWritable(): this;
-    getTextContent(_includeInert?: boolean, _includeDirectionless?: false): string;
-    getTextContentSize(includeInert?: boolean, includeDirectionless?: false): number;
+    getTextContent(): string;
+    getTextContentSize(): number;
     createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
     updateDOM(_prevNode: unknown, _dom: HTMLElement, _config: EditorConfig): boolean;
     exportDOM(editor: LexicalEditor): DOMExportOutput;

package/LexicalNormalization.d.ts

@@ -5,5 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { TextNode } from '.';
+import type { RangeSelection, TextNode } from '.';
 export declare function $normalizeTextNode(textNode: TextNode): void;
+export declare function $normalizeSelection(selection: RangeSelection): RangeSelection;

package/LexicalSelection.d.ts

@@ -69,6 +69,7 @@ export declare class NodeSelection implements BaseSelection {
     extract(): Array<LexicalNode>;
     insertRawText(text: string): void;
     insertText(): void;
+    insertNodes(nodes: Array<LexicalNode>, selectStart?: boolean): boolean;
     getNodes(): Array<LexicalNode>;
     getTextContent(): string;
 }
@@ -95,11 +96,12 @@ export declare class GridSelection implements BaseSelection {
     extract(): Array<LexicalNode>;
     insertRawText(text: string): void;
     insertText(): void;
+    insertNodes(nodes: Array<LexicalNode>, selectStart?: boolean): boolean;
     getShape(): GridSelectionShape;
     getNodes(): Array<LexicalNode>;
     getTextContent(): string;
 }
-export declare function $isGridSelection(x: unknown): x is GridSelection;
+export declare function DEPRECATED_$isGridSelection(x: unknown): x is GridSelection;
 export declare class RangeSelection implements BaseSelection {
     anchor: PointType;
     focus: PointType;
@@ -135,7 +137,7 @@ export declare function $isNodeSelection(x: unknown): x is NodeSelection;
 export declare function internalMakeRangeSelection(anchorKey: NodeKey, anchorOffset: number, focusKey: NodeKey, focusOffset: number, anchorType: 'text' | 'element', focusType: 'text' | 'element'): RangeSelection;
 export declare function $createRangeSelection(): RangeSelection;
 export declare function $createNodeSelection(): NodeSelection;
-export declare function $createGridSelection(): GridSelection;
+export declare function DEPRECATED_$createGridSelection(): GridSelection;
 export declare function internalCreateSelection(editor: LexicalEditor): null | RangeSelection | NodeSelection | GridSelection;
 export declare function internalCreateRangeSelection(lastSelection: null | RangeSelection | NodeSelection | GridSelection, domSelection: Selection | null, editor: LexicalEditor): null | RangeSelection;
 export declare function $getSelection(): null | RangeSelection | NodeSelection | GridSelection;
@@ -145,3 +147,4 @@ export declare function applySelectionTransforms(nextEditorState: EditorState, e
 export declare function moveSelectionPointToSibling(point: PointType, node: LexicalNode, parent: ElementNode, prevSibling: LexicalNode | null, nextSibling: LexicalNode | null): void;
 export declare function adjustPointOffsetForMergedSibling(point: PointType, isBefore: boolean, key: NodeKey, target: TextNode, textLength: number): void;
 export declare function updateDOMSelection(prevSelection: RangeSelection | NodeSelection | GridSelection | null, nextSelection: RangeSelection | NodeSelection | GridSelection | null, editor: LexicalEditor, domSelection: Selection, tags: Set<string>, rootElement: HTMLElement): void;
+export declare function $insertNodes(nodes: Array<LexicalNode>, selectStart?: boolean): boolean;

package/LexicalUtils.d.ts

@@ -24,8 +24,7 @@ export declare function isSelectionCapturedInDecoratorInput(anchorDOM: Node): bo
 export declare function isSelectionWithinEditor(editor: LexicalEditor, anchorDOM: null | Node, focusDOM: null | Node): boolean;
 export declare function getNearestEditorFromDOMNode(node: Node | null): LexicalEditor | null;
 export declare function getTextDirection(text: string): 'ltr' | 'rtl' | null;
-export declare function $isTokenOrInertOrSegmented(node: TextNode): boolean;
-export declare function $isTokenOrInert(node: TextNode): boolean;
+export declare function $isTokenOrSegmented(node: TextNode): boolean;
 export declare function getDOMTextNode(element: Node | null): Text | null;
 export declare function toggleTextFormatType(format: number, type: TextFormatType, alignWithFormat: null | number): number;
 export declare function $isLeafNode(node: LexicalNode | null | undefined): node is TextNode | LineBreakNode | DecoratorNode<unknown>;
@@ -95,5 +94,8 @@ export declare function scrollIntoViewIfNeeded(editor: LexicalEditor, anchor: Po
 export declare function $hasUpdateTag(tag: string): boolean;
 export declare function $addUpdateTag(tag: string): void;
 export declare function $maybeMoveChildrenSelectionToParent(parentNode: LexicalNode, offset?: number): RangeSelection | NodeSelection | GridSelection | null;
+export declare function $hasAncestor(child: LexicalNode, targetNode: LexicalNode): boolean;
 export declare function getDefaultView(domElem: HTMLElement): Window | null;
 export declare function getWindow(editor: LexicalEditor): Window;
+export declare function $isInlineElementOrDecoratorNode(node: LexicalNode): boolean;
+export declare function $isRootOrShadowRoot(node: null | LexicalNode): boolean;

package/LexicalVersion.d.ts

@@ -5,4 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-export declare const VERSION = "0.4.0";
+export declare const VERSION = "0.4.1";

package/index.d.ts

@@ -17,15 +17,15 @@ export type { SerializedTextNode, TextFormatType, TextModeType, } from './nodes/
 export { BLUR_COMMAND, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, CLEAR_EDITOR_COMMAND, CLEAR_HISTORY_COMMAND, CLICK_COMMAND, CONTROLLED_TEXT_INSERTION_COMMAND, COPY_COMMAND, createCommand, CUT_COMMAND, DELETE_CHARACTER_COMMAND, DELETE_LINE_COMMAND, DELETE_WORD_COMMAND, DRAGEND_COMMAND, DRAGOVER_COMMAND, DRAGSTART_COMMAND, DROP_COMMAND, FOCUS_COMMAND, FORMAT_ELEMENT_COMMAND, FORMAT_TEXT_COMMAND, INDENT_CONTENT_COMMAND, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, KEY_MODIFIER_COMMAND, KEY_SPACE_COMMAND, KEY_TAB_COMMAND, MOVE_TO_END, MOVE_TO_START, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, REDO_COMMAND, REMOVE_TEXT_COMMAND, SELECTION_CHANGE_COMMAND, UNDO_COMMAND, } from './LexicalCommands';
 export { COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, createEditor, } from './LexicalEditor';
 export type { EventHandler } from './LexicalEvents';
-export { $createGridSelection, $createNodeSelection, $createRangeSelection, $getPreviousSelection, $getSelection, $isGridSelection, $isNodeSelection, $isRangeSelection, } from './LexicalSelection';
+export { $createNodeSelection, $createRangeSelection, $getPreviousSelection, $getSelection, $insertNodes, $isNodeSelection, $isRangeSelection, DEPRECATED_$createGridSelection, DEPRECATED_$isGridSelection, } from './LexicalSelection';
 export { $parseSerializedNode } from './LexicalUpdates';
-export { $getDecoratorNode, $getNearestNodeFromDOMNode, $getNodeByKey, $getRoot, $isLeafNode, $nodesOfType, $setCompositionKey, $setSelection, } from './LexicalUtils';
+export { $addUpdateTag, $getDecoratorNode, $getNearestNodeFromDOMNode, $getNodeByKey, $getRoot, $hasAncestor, $isInlineElementOrDecoratorNode, $isLeafNode, $isRootOrShadowRoot, $nodesOfType, $setCompositionKey, $setSelection, } from './LexicalUtils';
 export { VERSION } from './LexicalVersion';
 export { $isDecoratorNode, DecoratorNode } from './nodes/LexicalDecoratorNode';
 export { $isElementNode, ElementNode } from './nodes/LexicalElementNode';
-export { $isGridCellNode, GridCellNode } from './nodes/LexicalGridCellNode';
-export { $isGridNode, GridNode } from './nodes/LexicalGridNode';
-export { $isGridRowNode, GridRowNode } from './nodes/LexicalGridRowNode';
+export { DEPRECATED_$isGridCellNode, DEPRECATED_GridCellNode, } from './nodes/LexicalGridCellNode';
+export { DEPRECATED_$isGridNode, DEPRECATED_GridNode, } from './nodes/LexicalGridNode';
+export { DEPRECATED_$isGridRowNode, DEPRECATED_GridRowNode, } from './nodes/LexicalGridRowNode';
 export type { SerializedLineBreakNode } from './nodes/LexicalLineBreakNode';
 export { $createLineBreakNode, $isLineBreakNode, LineBreakNode, } from './nodes/LexicalLineBreakNode';
 export type { SerializedParagraphNode } from './nodes/LexicalParagraphNode';

package/nodes/LexicalDecoratorNode.d.ts

@@ -14,6 +14,6 @@ export declare class DecoratorNode<T> extends LexicalNode {
     constructor(key?: NodeKey);
     decorate(editor: LexicalEditor, config: EditorConfig): T;
     isIsolated(): boolean;
-    isTopLevel(): boolean;
+    isInline(): boolean;
 }
 export declare function $isDecoratorNode<T>(node: LexicalNode | null | undefined): node is DecoratorNode<T>;

package/nodes/LexicalElementNode.d.ts

@@ -37,15 +37,16 @@ export declare class ElementNode extends LexicalNode {
     isEmpty(): boolean;
     isDirty(): boolean;
     isLastChild(): boolean;
-    getAllTextNodes(includeInert?: boolean): Array<TextNode>;
+    getAllTextNodes(): Array<TextNode>;
     getFirstDescendant<T extends LexicalNode>(): null | T;
     getLastDescendant<T extends LexicalNode>(): null | T;
     getDescendantByIndex<T extends LexicalNode>(index: number): null | T;
     getFirstChild<T extends LexicalNode>(): null | T;
     getFirstChildOrThrow<T extends LexicalNode>(): T;
     getLastChild<T extends LexicalNode>(): null | T;
+    getLastChildOrThrow<T extends LexicalNode>(): T;
     getChildAtIndex<T extends LexicalNode>(index: number): null | T;
-    getTextContent(includeInert?: boolean, includeDirectionless?: false): string;
+    getTextContent(): string;
     getDirection(): 'ltr' | 'rtl' | null;
     hasFormat(type: ElementFormatType): boolean;
     select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
@@ -70,6 +71,7 @@ export declare class ElementNode extends LexicalNode {
     canInsertTextBefore(): boolean;
     canInsertTextAfter(): boolean;
     isInline(): boolean;
+    isShadowRoot(): boolean;
     canMergeWith(node: ElementNode): boolean;
     extractWithChild(child: LexicalNode, selection: RangeSelection | NodeSelection | GridSelection | null, destination: 'clone' | 'html'): boolean;
 }

package/nodes/LexicalGridCellNode.d.ts

@@ -11,10 +11,10 @@ export declare type SerializedGridCellNode = Spread<{
     colSpan: number;
 }, SerializedElementNode>;
 /** @noInheritDoc */
-export declare class GridCellNode extends ElementNode {
+export declare class DEPRECATED_GridCellNode extends ElementNode {
     /** @internal */
     __colSpan: number;
     constructor(colSpan: number, key?: NodeKey);
     exportJSON(): SerializedGridCellNode;
 }
-export declare function $isGridCellNode(node: GridCellNode | LexicalNode | null | undefined): node is GridCellNode;
+export declare function DEPRECATED_$isGridCellNode(node: DEPRECATED_GridCellNode | LexicalNode | null | undefined): node is DEPRECATED_GridCellNode;

package/nodes/LexicalGridNode.d.ts

@@ -7,6 +7,6 @@
  */
 import type { LexicalNode } from '../LexicalNode';
 import { ElementNode } from './LexicalElementNode';
-export declare class GridNode extends ElementNode {
+export declare class DEPRECATED_GridNode extends ElementNode {
 }
-export declare function $isGridNode(node: LexicalNode | null | undefined): node is GridNode;
+export declare function DEPRECATED_$isGridNode(node: LexicalNode | null | undefined): node is DEPRECATED_GridNode;

package/nodes/LexicalGridRowNode.d.ts

@@ -7,6 +7,6 @@
  */
 import type { LexicalNode } from '../LexicalNode';
 import { ElementNode } from './LexicalElementNode';
-export declare class GridRowNode extends ElementNode {
+export declare class DEPRECATED_GridRowNode extends ElementNode {
 }
-export declare function $isGridRowNode(node: LexicalNode | null | undefined): node is GridRowNode;
+export declare function DEPRECATED_$isGridRowNode(node: LexicalNode | null | undefined): node is DEPRECATED_GridRowNode;

package/nodes/LexicalRootNode.d.ts

@@ -17,7 +17,7 @@ export declare class RootNode extends ElementNode {
     static clone(): RootNode;
     constructor();
     getTopLevelElementOrThrow(): never;
-    getTextContent(includeInert?: boolean, includeDirectionless?: false): string;
+    getTextContent(): string;
     remove(): never;
     replace<N = LexicalNode>(node: N): never;
     insertBefore(nodeToInsert: LexicalNode): LexicalNode;

package/nodes/LexicalTextNode.d.ts

@@ -17,9 +17,9 @@ export declare type SerializedTextNode = Spread<{
     style: string;
     text: string;
 }, SerializedLexicalNode>;
-export declare type TextFormatType = 'bold' | 'underline' | 'strikethrough' | 'italic' | 'code' | 'subscript' | 'superscript';
 export declare type TextDetailType = 'directionless' | 'unmergable';
-export declare type TextModeType = 'normal' | 'token' | 'segmented' | 'inert';
+export declare type TextFormatType = 'bold' | 'underline' | 'strikethrough' | 'italic' | 'code' | 'subscript' | 'superscript';
+export declare type TextModeType = 'normal' | 'token' | 'segmented';
 export declare type TextMark = {
     end: null | number;
     id: string;
@@ -43,12 +43,11 @@ export declare class TextNode extends LexicalNode {
     isToken(): boolean;
     isComposing(): boolean;
     isSegmented(): boolean;
-    isInert(): boolean;
     isDirectionless(): boolean;
     isUnmergeable(): boolean;
     hasFormat(type: TextFormatType): boolean;
     isSimpleText(): boolean;
-    getTextContent(includeInert?: boolean, includeDirectionless?: false): string;
+    getTextContent(): string;
     getFormatFlags(type: TextFormatType, alignWithFormat: null | number): number;
     createDOM(config: EditorConfig): HTMLElement;
     updateDOM(prevNode: TextNode, dom: HTMLElement, config: EditorConfig): boolean;

package/package.json

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