lexical 0.6.4 → 0.7.0

package/LexicalConstants.d.ts

@@ -29,6 +29,8 @@ export declare const IS_ALIGN_LEFT = 1;
 export declare const IS_ALIGN_CENTER = 2;
 export declare const IS_ALIGN_RIGHT = 3;
 export declare const IS_ALIGN_JUSTIFY = 4;
+export declare const IS_ALIGN_START = 5;
+export declare const IS_ALIGN_END = 6;
 export declare const NON_BREAKING_SPACE = "\u00A0";
 export declare const COMPOSITION_SUFFIX: string;
 export declare const DOUBLE_LINE_BREAK = "\n\n";

package/LexicalEditor.d.ts

@@ -37,6 +37,7 @@ export declare type EditorFocusOptions = {
     defaultSelection?: 'rootStart' | 'rootEnd';
 };
 export declare type EditorThemeClasses = {
+    blockCursor?: EditorThemeClassName;
     characterLimit?: EditorThemeClassName;
     code?: EditorThemeClassName;
     codeHighlight?: Record<string, EditorThemeClassName>;
@@ -168,7 +169,7 @@ declare type Listeners = {
 export declare type Listener = DecoratorListener | EditableListener | MutationListener | RootListener | TextContentListener | UpdateListener;
 export declare type ListenerType = 'update' | 'root' | 'decorator' | 'textcontent' | 'mutation' | 'editable';
 export declare type TransformerType = 'text' | 'decorator' | 'element' | 'root';
-export declare type IntentionallyMarkedAsDirtyElement = boolean;
+declare type IntentionallyMarkedAsDirtyElement = boolean;
 declare type DOMConversionCache = Map<string, Array<(node: Node) => DOMConversion | null>>;
 export declare type SerializedEditor = {
     editorState: SerializedEditorState;
@@ -218,6 +219,7 @@ export declare class LexicalEditor {
     _htmlConversions: DOMConversionCache;
     _window: null | Window;
     _editable: boolean;
+    _blockCursorElement: null | HTMLDivElement;
     constructor(editorState: EditorState, parentEditor: null | LexicalEditor, nodes: RegisteredNodes, config: EditorConfig, onError: ErrorHandler, htmlConversions: DOMConversionCache, editable: boolean);
     isComposing(): boolean;
     registerUpdateListener(listener: UpdateListener): () => void;

package/LexicalGC.d.ts

@@ -5,8 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { IntentionallyMarkedAsDirtyElement, LexicalEditor } from './LexicalEditor';
+import type { LexicalEditor } from './LexicalEditor';
 import type { EditorState } from './LexicalEditorState';
 import type { NodeKey } from './LexicalNode';
 export declare function $garbageCollectDetachedDecorators(editor: LexicalEditor, pendingEditorState: EditorState): void;
+declare type IntentionallyMarkedAsDirtyElement = boolean;
 export declare function $garbageCollectDetachedNodes(prevEditorState: EditorState, editorState: EditorState, dirtyLeaves: Set<NodeKey>, dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>): void;
+export {};

package/LexicalNode.d.ts

@@ -14,7 +14,6 @@ export declare type SerializedLexicalNode = {
     version: number;
 };
 export declare function removeNode(nodeToRemove: LexicalNode, restoreSelection: boolean, preserveEmptyParent?: boolean): void;
-export declare function $getNodeByKeyOrThrow<N extends LexicalNode>(key: NodeKey): N;
 export declare type DOMConversion<T extends HTMLElement = HTMLElement> = {
     conversion: DOMConversionFn<T>;
     priority: 0 | 1 | 2 | 3 | 4;
@@ -80,9 +79,9 @@ export declare class LexicalNode {
     exportJSON(): SerializedLexicalNode;
     static importJSON(_serializedNode: SerializedLexicalNode): LexicalNode;
     remove(preserveEmptyParent?: boolean): void;
-    replace<N extends LexicalNode>(replaceWith: N): N;
-    insertAfter(nodeToInsert: LexicalNode): LexicalNode;
-    insertBefore(nodeToInsert: LexicalNode): LexicalNode;
+    replace<N extends LexicalNode>(replaceWith: N, restoreSelection?: boolean): N;
+    insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+    insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
     selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
     selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
     markDirty(): void;

package/LexicalReconciler.d.ts

@@ -5,8 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { IntentionallyMarkedAsDirtyElement, LexicalEditor, MutatedNodes } from './LexicalEditor';
+import type { LexicalEditor, MutatedNodes } from './LexicalEditor';
 import type { NodeKey } from './LexicalNode';
 import { EditorState } from './LexicalEditorState';
+declare type IntentionallyMarkedAsDirtyElement = boolean;
 export declare function reconcileRoot(prevEditorState: EditorState, nextEditorState: EditorState, editor: LexicalEditor, dirtyType: 0 | 1 | 2, dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>, dirtyLeaves: Set<NodeKey>): MutatedNodes;
 export declare function storeDOMWithKey(key: NodeKey, dom: HTMLElement, editor: LexicalEditor): void;
+export {};

package/LexicalSelection.d.ts

@@ -144,6 +144,6 @@ export declare function $updateElementSelectionOnCreateDeleteNode(selection: Ran
 export declare function applySelectionTransforms(nextEditorState: EditorState, editor: LexicalEditor): void;
 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 updateDOMSelection(prevSelection: RangeSelection | NodeSelection | GridSelection | null, nextSelection: RangeSelection | NodeSelection | GridSelection | null, editor: LexicalEditor, domSelection: Selection, tags: Set<string>, rootElement: HTMLElement, dirtyLeavesCount: number): void;
 export declare function $insertNodes(nodes: Array<LexicalNode>, selectStart?: boolean): boolean;
 export declare function $getTextContent(): string;

package/LexicalUtils.d.ts

@@ -29,7 +29,7 @@ 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>;
 export declare function $setNodeKey(node: LexicalNode, existingKey: NodeKey | null | undefined): void;
-export declare function removeFromParent(writableNode: LexicalNode): void;
+export declare function removeFromParent(node: LexicalNode): void;
 export declare function internalMarkNodeAsDirty(node: LexicalNode): void;
 export declare function internalMarkSiblingsAsDirty(node: LexicalNode): void;
 export declare function $setCompositionKey(compositionKey: null | NodeKey): void;
@@ -86,7 +86,7 @@ export declare function isDelete(keyCode: number): boolean;
 export declare function getCachedClassNameArray(classNamesTheme: EditorThemeClasses, classNameThemeType: string): Array<string>;
 export declare function setMutatedNode(mutatedNodes: MutatedNodes, registeredNodes: RegisteredNodes, mutationListeners: MutationListeners, node: LexicalNode, mutation: NodeMutation): void;
 export declare function $nodesOfType<T extends LexicalNode>(klass: Klass<T>): Array<T>;
-export declare function $getDecoratorNode(focus: PointType, isBackward: boolean): null | LexicalNode;
+export declare function $getAdjacentNode(focus: PointType, isBackward: boolean): null | LexicalNode;
 export declare function isFirefoxClipboardEvents(editor: LexicalEditor): boolean;
 export declare function dispatchCommand<TCommand extends LexicalCommand<unknown>>(editor: LexicalEditor, command: TCommand, payload: CommandPayloadType<TCommand>): boolean;
 export declare function $textContentRequiresDoubleLinebreakAtEnd(node: ElementNode): boolean;
@@ -105,3 +105,6 @@ export declare function $isRootOrShadowRoot(node: null | LexicalNode): boolean;
 export declare function $copyNode<T extends LexicalNode>(node: T): T;
 export declare function $applyNodeReplacement<N extends LexicalNode>(node: LexicalNode): N;
 export declare function errorOnInsertTextNodeOnRoot(node: LexicalNode, insertNode: LexicalNode): void;
+export declare function $getNodeByKeyOrThrow<N extends LexicalNode>(key: NodeKey): N;
+export declare function removeDOMBlockCursorElement(blockCursorElement: HTMLElement, editor: LexicalEditor, rootElement: HTMLElement): void;
+export declare function updateDOMBlockCursorElement(editor: LexicalEditor, rootElement: HTMLElement, nextSelection: null | RangeSelection | NodeSelection | GridSelection): void;

package/LexicalVersion.d.ts

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

package/index.d.ts

@@ -7,7 +7,7 @@
  *
  */
 export type { PasteCommandType } from './LexicalCommands';
-export type { CommandListenerPriority, CommandPayloadType, EditableListener, EditorConfig, EditorThemeClasses, IntentionallyMarkedAsDirtyElement, Klass, LexicalCommand, LexicalEditor, MutationListener, NodeMutation, SerializedEditor, Spread, } from './LexicalEditor';
+export type { CommandListenerPriority, CommandPayloadType, 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';
@@ -21,7 +21,7 @@ export type { EventHandler } from './LexicalEvents';
 export { $normalizeSelection as $normalizeSelection__EXPERIMENTAL } from './LexicalNormalization';
 export { $createNodeSelection, $createRangeSelection, $getPreviousSelection, $getSelection, $getTextContent, $insertNodes, $isNodeSelection, $isRangeSelection, DEPRECATED_$createGridSelection, DEPRECATED_$isGridSelection, } from './LexicalSelection';
 export { $parseSerializedNode } from './LexicalUpdates';
-export { $addUpdateTag, $applyNodeReplacement, $copyNode, $getDecoratorNode, $getNearestNodeFromDOMNode, $getNearestRootOrShadowRoot, $getNodeByKey, $getRoot, $hasAncestor, $isInlineElementOrDecoratorNode, $isLeafNode, $isRootOrShadowRoot, $nodesOfType, $setCompositionKey, $setSelection, } from './LexicalUtils';
+export { $addUpdateTag, $applyNodeReplacement, $copyNode, $getAdjacentNode, $getNearestNodeFromDOMNode, $getNearestRootOrShadowRoot, $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';

package/nodes/LexicalElementNode.d.ts

@@ -16,11 +16,9 @@ export declare type SerializedElementNode = Spread<{
     format: ElementFormatType;
     indent: number;
 }, SerializedLexicalNode>;
-export declare type ElementFormatType = 'left' | 'center' | 'right' | 'justify' | '';
+export declare type ElementFormatType = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
 /** @noInheritDoc */
 export declare class ElementNode extends LexicalNode {
-    /** @internal */
-    __children: Array<NodeKey>;
     /** @internal */
     __first: null | NodeKey;
     /** @internal */
@@ -65,7 +63,7 @@ export declare class ElementNode extends LexicalNode {
     setIndent(indentLevel: number): this;
     splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): this;
     exportJSON(): SerializedElementNode;
-    insertNewAfter(selection: RangeSelection): null | LexicalNode;
+    insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): null | LexicalNode;
     canInsertTab(): boolean;
     canIndent(): boolean;
     collapseAtStart(selection: RangeSelection): boolean;

package/nodes/LexicalLineBreakNode.d.ts

@@ -21,7 +21,7 @@ export declare class LineBreakNode extends LexicalNode {
     updateDOM(): false;
     static importDOM(): DOMConversionMap | null;
     static importJSON(serializedLineBreakNode: SerializedLineBreakNode): LineBreakNode;
-    exportJSON(): SerializedLineBreakNode;
+    exportJSON(): SerializedLexicalNode;
 }
 export declare function $createLineBreakNode(): LineBreakNode;
 export declare function $isLineBreakNode(node: LexicalNode | null | undefined): node is LineBreakNode;

package/nodes/LexicalParagraphNode.d.ts

@@ -8,7 +8,7 @@
 import type { EditorConfig, LexicalEditor } from '../LexicalEditor';
 import type { DOMConversionMap, DOMExportOutput, LexicalNode } from '../LexicalNode';
 import type { SerializedElementNode } from './LexicalElementNode';
-import type { Spread } from 'lexical';
+import type { RangeSelection, Spread } from 'lexical';
 import { ElementNode } from './LexicalElementNode';
 export declare type SerializedParagraphNode = Spread<{
     type: 'paragraph';
@@ -23,8 +23,8 @@ export declare class ParagraphNode extends ElementNode {
     static importDOM(): DOMConversionMap | null;
     exportDOM(editor: LexicalEditor): DOMExportOutput;
     static importJSON(serializedNode: SerializedParagraphNode): ParagraphNode;
-    exportJSON(): SerializedParagraphNode;
-    insertNewAfter(): ParagraphNode;
+    exportJSON(): SerializedElementNode;
+    insertNewAfter(_: RangeSelection, restoreSelection: boolean): ParagraphNode;
     collapseAtStart(): boolean;
 }
 export declare function $createParagraphNode(): ParagraphNode;

package/nodes/LexicalTextNode.d.ts

@@ -29,9 +29,13 @@ export declare type TextMarks = Array<TextMark>;
 /** @noInheritDoc */
 export declare class TextNode extends LexicalNode {
     __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;

package/package.json

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