lexical 0.3.3 → 0.3.6

package/LexicalCommands.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 { ElementFormatType, LexicalCommand, TextFormatType } from 'lexical';
+export declare function createCommand<T>(): LexicalCommand<T>;
+export declare const SELECTION_CHANGE_COMMAND: LexicalCommand<void>;
+export declare const CLICK_COMMAND: LexicalCommand<MouseEvent>;
+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<string>;
+export declare const PASTE_COMMAND: LexicalCommand<ClipboardEvent>;
+export declare const REMOVE_TEXT_COMMAND: LexicalCommand<void>;
+export declare const DELETE_WORD_COMMAND: LexicalCommand<boolean>;
+export declare const DELETE_LINE_COMMAND: LexicalCommand<boolean>;
+export declare const FORMAT_TEXT_COMMAND: LexicalCommand<TextFormatType>;
+export declare const UNDO_COMMAND: LexicalCommand<void>;
+export declare const REDO_COMMAND: LexicalCommand<void>;
+export declare const KEY_ARROW_RIGHT_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const MOVE_TO_END: LexicalCommand<KeyboardEvent>;
+export declare const KEY_ARROW_LEFT_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const MOVE_TO_START: LexicalCommand<KeyboardEvent>;
+export declare const KEY_ARROW_UP_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const KEY_ARROW_DOWN_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const KEY_ENTER_COMMAND: LexicalCommand<KeyboardEvent | null>;
+export declare const KEY_SPACE_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const KEY_BACKSPACE_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const KEY_ESCAPE_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const KEY_DELETE_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const KEY_TAB_COMMAND: LexicalCommand<KeyboardEvent>;
+export declare const INDENT_CONTENT_COMMAND: LexicalCommand<void>;
+export declare const OUTDENT_CONTENT_COMMAND: LexicalCommand<void>;
+export declare const DROP_COMMAND: LexicalCommand<DragEvent>;
+export declare const FORMAT_ELEMENT_COMMAND: LexicalCommand<ElementFormatType>;
+export declare const DRAGSTART_COMMAND: LexicalCommand<DragEvent>;
+export declare const DRAGOVER_COMMAND: LexicalCommand<DragEvent>;
+export declare const DRAGEND_COMMAND: LexicalCommand<DragEvent>;
+export declare const COPY_COMMAND: LexicalCommand<ClipboardEvent>;
+export declare const CUT_COMMAND: LexicalCommand<ClipboardEvent>;
+export declare const CLEAR_EDITOR_COMMAND: LexicalCommand<void>;
+export declare const CLEAR_HISTORY_COMMAND: LexicalCommand<void>;
+export declare const CAN_REDO_COMMAND: LexicalCommand<boolean>;
+export declare const CAN_UNDO_COMMAND: LexicalCommand<boolean>;
+export declare const FOCUS_COMMAND: LexicalCommand<FocusEvent>;
+export declare const BLUR_COMMAND: LexicalCommand<FocusEvent>;
+export declare const KEY_MODIFIER_COMMAND: LexicalCommand<KeyboardEvent>;

package/LexicalConstants.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { ElementFormatType } from './nodes/LexicalElementNode';
+import type { TextDetailType, TextFormatType, TextModeType } from './nodes/LexicalTextNode';
+export declare const DOM_ELEMENT_TYPE = 1;
+export declare const DOM_TEXT_TYPE = 3;
+export declare const NO_DIRTY_NODES = 0;
+export declare const HAS_DIRTY_NODES = 1;
+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;
+export declare const IS_UNDERLINE: number;
+export declare const IS_CODE: number;
+export declare const IS_SUBSCRIPT: number;
+export declare const IS_SUPERSCRIPT: number;
+export declare const IS_DIRECTIONLESS = 1;
+export declare const IS_UNMERGEABLE: number;
+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 NON_BREAKING_SPACE = "\u00A0";
+export declare const COMPOSITION_SUFFIX: string;
+export declare const DOUBLE_LINE_BREAK = "\n\n";
+export declare const COMPOSITION_START_CHAR: string;
+export declare const RTL_REGEX: RegExp;
+export declare const LTR_REGEX: RegExp;
+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_TYPE_TO_MODE: Record<number, TextModeType>;

package/LexicalEditor.d.ts

@@ -0,0 +1,199 @@
+/**
+ * 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 { EditorState, SerializedEditorState } from './LexicalEditorState';
+import type { DOMConversion, LexicalNode, NodeKey } from './LexicalNode';
+export declare type Spread<T1, T2> = Omit<T2, keyof T1> & T1;
+export declare type Klass<T extends LexicalNode> = {
+    new (...args: any[]): T;
+} & Omit<LexicalNode, 'constructor'>;
+export declare type EditorThemeClassName = string;
+export declare type TextNodeThemeClasses = {
+    base?: EditorThemeClassName;
+    bold?: EditorThemeClassName;
+    code?: EditorThemeClassName;
+    italic?: EditorThemeClassName;
+    strikethrough?: EditorThemeClassName;
+    subscript?: EditorThemeClassName;
+    superscript?: EditorThemeClassName;
+    underline?: EditorThemeClassName;
+    underlineStrikethrough?: EditorThemeClassName;
+};
+export declare type EditorUpdateOptions = {
+    onUpdate?: () => void;
+    skipTransforms?: true;
+    tag?: string;
+};
+export declare type EditorSetOptions = {
+    tag?: string;
+};
+export declare type EditorThemeClasses = {
+    characterLimit?: EditorThemeClassName;
+    code?: EditorThemeClassName;
+    codeHighlight?: Record<string, EditorThemeClassName>;
+    hashtag?: EditorThemeClassName;
+    heading?: {
+        h1?: EditorThemeClassName;
+        h2?: EditorThemeClassName;
+        h3?: EditorThemeClassName;
+        h4?: EditorThemeClassName;
+        h5?: EditorThemeClassName;
+        h6?: EditorThemeClassName;
+    };
+    image?: EditorThemeClassName;
+    link?: EditorThemeClassName;
+    list?: {
+        ul?: EditorThemeClassName;
+        ulDepth?: Array<EditorThemeClassName>;
+        ol?: EditorThemeClassName;
+        olDepth?: Array<EditorThemeClassName>;
+        listitem?: EditorThemeClassName;
+        listitemChecked?: EditorThemeClassName;
+        listitemUnchecked?: EditorThemeClassName;
+        nested?: {
+            list?: EditorThemeClassName;
+            listitem?: EditorThemeClassName;
+        };
+    };
+    ltr?: EditorThemeClassName;
+    mark?: EditorThemeClassName;
+    markOverlap?: EditorThemeClassName;
+    paragraph?: EditorThemeClassName;
+    quote?: EditorThemeClassName;
+    root?: EditorThemeClassName;
+    rtl?: EditorThemeClassName;
+    table?: EditorThemeClassName;
+    tableCell?: EditorThemeClassName;
+    tableCellHeader?: EditorThemeClassName;
+    tableRow?: EditorThemeClassName;
+    text?: TextNodeThemeClasses;
+    embedBlock?: {
+        base?: EditorThemeClassName;
+        focus?: EditorThemeClassName;
+    };
+    [key: string]: any;
+};
+export declare type EditorConfig = {
+    disableEvents?: boolean;
+    namespace: string;
+    theme: EditorThemeClasses;
+};
+export declare type RegisteredNodes = Map<string, RegisteredNode>;
+export declare type RegisteredNode = {
+    klass: Klass<LexicalNode>;
+    transforms: Set<Transform<LexicalNode>>;
+};
+export declare type Transform<T extends LexicalNode> = (node: T) => void;
+export declare type ErrorHandler = (error: Error) => void;
+export declare type MutationListeners = Map<MutationListener, Klass<LexicalNode>>;
+export declare type MutatedNodes = Map<Klass<LexicalNode>, Map<NodeKey, NodeMutation>>;
+export declare type NodeMutation = 'created' | 'updated' | 'destroyed';
+export declare type UpdateListener = (arg0: {
+    dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
+    dirtyLeaves: Set<NodeKey>;
+    editorState: EditorState;
+    normalizedNodes: Set<NodeKey>;
+    prevEditorState: EditorState;
+    tags: Set<string>;
+}) => void;
+export declare type DecoratorListener<T = never> = (decorator: Record<NodeKey, T>) => void;
+export declare type RootListener = (rootElement: null | HTMLElement, prevRootElement: null | HTMLElement) => void;
+export declare type TextContentListener = (text: string) => void;
+export declare type MutationListener = (nodes: Map<NodeKey, NodeMutation>) => void;
+export declare type CommandListener<P> = (payload: P, editor: LexicalEditor) => boolean;
+export declare type ReadOnlyListener = (readOnly: boolean) => void;
+export declare type CommandListenerPriority = 0 | 1 | 2 | 3 | 4;
+export declare const COMMAND_PRIORITY_EDITOR = 0;
+export declare const COMMAND_PRIORITY_LOW = 1;
+export declare const COMMAND_PRIORITY_NORMAL = 2;
+export declare const COMMAND_PRIORITY_HIGH = 3;
+export declare const COMMAND_PRIORITY_CRITICAL = 4;
+export declare type LexicalCommand<T = never> = Readonly<Record<string, unknown>>;
+declare type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<unknown>>>>;
+declare type Listeners = {
+    decorator: Set<DecoratorListener>;
+    mutation: MutationListeners;
+    readonly: Set<ReadOnlyListener>;
+    root: Set<RootListener>;
+    textcontent: Set<TextContentListener>;
+    update: Set<UpdateListener>;
+};
+export declare type Listener = DecoratorListener | ReadOnlyListener | MutationListener | RootListener | TextContentListener | UpdateListener;
+export declare type ListenerType = 'update' | 'root' | 'decorator' | 'textcontent' | 'mutation' | 'readonly';
+export declare type TransformerType = 'text' | 'decorator' | 'element' | 'root';
+export declare type IntentionallyMarkedAsDirtyElement = boolean;
+declare type DOMConversionCache = Map<string, Array<(node: Node) => DOMConversion | null>>;
+export declare type SerializedEditor = {
+    editorState: SerializedEditorState;
+};
+export declare function resetEditor(editor: LexicalEditor, prevRootElement: null | HTMLElement, nextRootElement: null | HTMLElement, pendingEditorState: EditorState): void;
+export declare function createEditor(editorConfig?: {
+    disableEvents?: boolean;
+    editorState?: EditorState;
+    namespace?: string;
+    nodes?: ReadonlyArray<Klass<LexicalNode>>;
+    onError?: ErrorHandler;
+    parentEditor?: LexicalEditor;
+    readOnly?: boolean;
+    theme?: EditorThemeClasses;
+}): LexicalEditor;
+export declare class LexicalEditor {
+    _headless: boolean;
+    _parentEditor: null | LexicalEditor;
+    _rootElement: null | HTMLElement;
+    _editorState: EditorState;
+    _pendingEditorState: null | EditorState;
+    _compositionKey: null | NodeKey;
+    _deferred: Array<() => void>;
+    _keyToDOMMap: Map<NodeKey, HTMLElement>;
+    _updates: Array<[() => void, EditorUpdateOptions | undefined]>;
+    _updating: boolean;
+    _listeners: Listeners;
+    _commands: Commands;
+    _nodes: RegisteredNodes;
+    _decorators: Record<NodeKey, unknown>;
+    _pendingDecorators: null | Record<NodeKey, unknown>;
+    _config: EditorConfig;
+    _dirtyType: 0 | 1 | 2;
+    _cloneNotNeeded: Set<NodeKey>;
+    _dirtyLeaves: Set<NodeKey>;
+    _dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
+    _normalizedNodes: Set<NodeKey>;
+    _updateTags: Set<string>;
+    _observer: null | MutationObserver;
+    _key: string;
+    _onError: ErrorHandler;
+    _htmlConversions: DOMConversionCache;
+    _readOnly: boolean;
+    constructor(editorState: EditorState, parentEditor: null | LexicalEditor, nodes: RegisteredNodes, config: EditorConfig, onError: ErrorHandler, htmlConversions: DOMConversionCache, readOnly: boolean);
+    isComposing(): boolean;
+    registerUpdateListener(listener: UpdateListener): () => void;
+    registerReadOnlyListener(listener: ReadOnlyListener): () => void;
+    registerDecoratorListener<T>(listener: DecoratorListener<T>): () => void;
+    registerTextContentListener(listener: TextContentListener): () => void;
+    registerRootListener(listener: RootListener): () => void;
+    registerCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
+    registerMutationListener(klass: Klass<LexicalNode>, listener: MutationListener): () => void;
+    registerNodeTransform<T extends LexicalNode>(klass: Klass<T>, listener: Transform<T>): () => void;
+    hasNodes<T extends Klass<LexicalNode>>(nodes: Array<T>): boolean;
+    dispatchCommand<P>(type: LexicalCommand<P>, payload: P): boolean;
+    getDecorators<T>(): Record<NodeKey, T>;
+    getRootElement(): null | HTMLElement;
+    getKey(): string;
+    setRootElement(nextRootElement: null | HTMLElement): void;
+    getElementByKey(key: NodeKey): HTMLElement | null;
+    getEditorState(): EditorState;
+    setEditorState(editorState: EditorState, options?: EditorSetOptions): void;
+    parseEditorState(maybeStringifiedEditorState: string | SerializedEditorState, updateFn?: () => void): EditorState;
+    update(updateFn: () => void, options?: EditorUpdateOptions): void;
+    focus(callbackFn?: () => void): void;
+    blur(): void;
+    isReadOnly(): boolean;
+    setReadOnly(readOnly: boolean): void;
+    toJSON(): SerializedEditor;
+}
+export {};

package/LexicalEditorState.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { LexicalEditor } from './LexicalEditor';
+import type { NodeMap } from './LexicalNode';
+import type { GridSelection, NodeSelection, RangeSelection } from './LexicalSelection';
+import type { SerializedRootNode } from './nodes/LexicalRootNode';
+export interface SerializedEditorState {
+    root: SerializedRootNode;
+}
+export declare function editorStateHasDirtySelection(editorState: EditorState, editor: LexicalEditor): boolean;
+export declare function cloneEditorState(current: EditorState): EditorState;
+export declare function createEmptyEditorState(): EditorState;
+export declare class EditorState {
+    _nodeMap: NodeMap;
+    _selection: null | RangeSelection | NodeSelection | GridSelection;
+    _flushSync: boolean;
+    _readOnly: boolean;
+    constructor(nodeMap: NodeMap, selection?: RangeSelection | NodeSelection | GridSelection | null);
+    isEmpty(): boolean;
+    read<V>(callbackFn: () => V): V;
+    clone(selection?: RangeSelection | NodeSelection | GridSelection | null): EditorState;
+    toJSON(): SerializedEditorState;
+}

package/LexicalEvents.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { LexicalEditor } from './LexicalEditor';
+import type { NodeKey } from './LexicalNode';
+export declare type EventHandler = (event: Event, editor: LexicalEditor) => void;
+export declare function addRootElementEvents(rootElement: HTMLElement, editor: LexicalEditor): void;
+export declare function removeRootElementEvents(rootElement: HTMLElement): void;
+export declare function markSelectionChangeFromDOMUpdate(): void;
+export declare function markCollapsedSelectionFormat(format: number, offset: number, key: NodeKey, timeStamp: number): void;

package/LexicalGC.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { IntentionallyMarkedAsDirtyElement, LexicalEditor } from './LexicalEditor';
+import type { EditorState } from './LexicalEditorState';
+import type { NodeKey } from './LexicalNode';
+export declare function $garbageCollectDetachedDecorators(editor: LexicalEditor, pendingEditorState: EditorState): void;
+export declare function $garbageCollectDetachedNodes(prevEditorState: EditorState, editorState: EditorState, dirtyLeaves: Set<NodeKey>, dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>): void;

package/LexicalMutations.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { LexicalEditor } from './LexicalEditor';
+export declare function getIsProcesssingMutations(): boolean;
+export declare function $flushMutations(editor: LexicalEditor, mutations: Array<MutationRecord>, observer: MutationObserver): void;
+export declare function flushRootMutations(editor: LexicalEditor): void;
+export declare function initMutationObserver(editor: LexicalEditor): void;

package/LexicalNode.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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, LexicalEditor } from './LexicalEditor';
+import type { RangeSelection } from './LexicalSelection';
+import { ElementNode } from '.';
+export declare type NodeMap = Map<NodeKey, LexicalNode>;
+export declare type SerializedLexicalNode = {
+    type: string;
+    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;
+};
+export declare type DOMConversionFn<T extends HTMLElement = HTMLElement> = (element: T, parent?: Node) => 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;
+export declare type DOMConversionOutput = {
+    after?: (childLexicalNodes: Array<LexicalNode>) => Array<LexicalNode>;
+    forChild?: DOMChildConversion;
+    node: LexicalNode | null;
+};
+export declare type DOMExportOutput = {
+    after?: (generatedElement: HTMLElement | null | undefined) => HTMLElement | null | undefined;
+    element: HTMLElement | null;
+};
+export declare type NodeKey = string;
+export declare class LexicalNode {
+    [x: string]: any;
+    __type: string;
+    __key: string;
+    __parent: null | NodeKey;
+    static getType(): string;
+    static clone(_data: unknown): LexicalNode;
+    constructor(key?: NodeKey);
+    getType(): string;
+    isAttached(): boolean;
+    isSelected(): boolean;
+    getKey(): NodeKey;
+    getIndexWithinParent(): number;
+    getParent<T extends ElementNode>(): T | null;
+    getParentOrThrow<T extends ElementNode>(): T;
+    getTopLevelElement(): ElementNode | this | null;
+    getTopLevelElementOrThrow(): ElementNode | this;
+    getParents(): Array<ElementNode>;
+    getParentKeys(): Array<NodeKey>;
+    getPreviousSibling<T extends LexicalNode>(): T | null;
+    getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+    getNextSibling<T extends LexicalNode>(): T | null;
+    getNextSiblings<T extends LexicalNode>(): Array<T>;
+    getCommonAncestor<T extends ElementNode = ElementNode>(node: LexicalNode): T | null;
+    is(object: LexicalNode | null | undefined): boolean;
+    isBefore(targetNode: LexicalNode): boolean;
+    isParentOf(targetNode: LexicalNode): boolean;
+    getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+    isDirty(): boolean;
+    getLatest(): this;
+    getWritable(): this;
+    getTextContent(_includeInert?: boolean, _includeDirectionless?: false): string;
+    getTextContentSize(includeInert?: boolean, includeDirectionless?: false): number;
+    createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+    updateDOM(_prevNode: unknown, _dom: HTMLElement, _config: EditorConfig): boolean;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    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;
+    selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+    selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+    markDirty(): void;
+}
+export {};

package/LexicalNormalization.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 { TextNode } from '.';
+export declare function $normalizeTextNode(textNode: TextNode): void;

package/LexicalReconciler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { IntentionallyMarkedAsDirtyElement, LexicalEditor, MutatedNodes } from './LexicalEditor';
+import type { NodeKey } from './LexicalNode';
+import { EditorState } from './LexicalEditorState';
+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;

package/LexicalSelection.d.ts

@@ -0,0 +1,147 @@
+/**
+ * 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 { LexicalEditor } from './LexicalEditor';
+import type { EditorState } from './LexicalEditorState';
+import type { LexicalNode, NodeKey } from './LexicalNode';
+import type { ElementNode } from './nodes/LexicalElementNode';
+import type { TextFormatType } from './nodes/LexicalTextNode';
+import { TextNode } from '.';
+export declare type TextPointType = {
+    _selection: RangeSelection | GridSelection;
+    getNode: () => TextNode;
+    is: (point: PointType) => boolean;
+    isAtNodeEnd: () => boolean;
+    isBefore: (point: PointType) => boolean;
+    key: NodeKey;
+    offset: number;
+    set: (key: NodeKey, offset: number, type: 'text' | 'element') => void;
+    type: 'text';
+};
+export declare type ElementPointType = {
+    _selection: RangeSelection | GridSelection;
+    getNode: () => ElementNode;
+    is: (point: PointType) => boolean;
+    isAtNodeEnd: () => boolean;
+    isBefore: (point: PointType) => boolean;
+    key: NodeKey;
+    offset: number;
+    set: (key: NodeKey, offset: number, type: 'text' | 'element') => void;
+    type: 'element';
+};
+export declare type PointType = TextPointType | ElementPointType;
+export declare class Point {
+    key: NodeKey;
+    offset: number;
+    type: 'text' | 'element';
+    _selection: RangeSelection | GridSelection | null;
+    constructor(key: NodeKey, offset: number, type: 'text' | 'element');
+    is(point: PointType): boolean;
+    isBefore(b: PointType): boolean;
+    getNode(): LexicalNode;
+    set(key: NodeKey, offset: number, type: 'text' | 'element'): void;
+}
+export declare function $moveSelectionPointToEnd(point: PointType, node: LexicalNode): void;
+export interface BaseSelection {
+    clone(): BaseSelection;
+    dirty: boolean;
+    extract(): Array<LexicalNode>;
+    getNodes(): Array<LexicalNode>;
+    getTextContent(): string;
+    insertRawText(text: string): void;
+    is(selection: null | RangeSelection | NodeSelection | GridSelection): boolean;
+}
+export declare class NodeSelection implements BaseSelection {
+    _nodes: Set<NodeKey>;
+    dirty: boolean;
+    _cachedNodes: null | Array<LexicalNode>;
+    constructor(objects: Set<NodeKey>);
+    is(selection: null | RangeSelection | NodeSelection | GridSelection): boolean;
+    add(key: NodeKey): void;
+    delete(key: NodeKey): void;
+    clear(): void;
+    has(key: NodeKey): boolean;
+    clone(): NodeSelection;
+    extract(): Array<LexicalNode>;
+    insertRawText(text: string): void;
+    insertText(): void;
+    getNodes(): Array<LexicalNode>;
+    getTextContent(): string;
+}
+export declare function $isRangeSelection(x: unknown): x is RangeSelection;
+export declare type GridSelectionShape = {
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+};
+export declare class GridSelection implements BaseSelection {
+    gridKey: NodeKey;
+    anchor: PointType;
+    focus: PointType;
+    dirty: boolean;
+    _cachedNodes: Array<LexicalNode> | null;
+    constructor(gridKey: NodeKey, anchor: PointType, focus: PointType);
+    is(selection: null | RangeSelection | NodeSelection | GridSelection): boolean;
+    set(gridKey: NodeKey, anchorCellKey: NodeKey, focusCellKey: NodeKey): void;
+    clone(): GridSelection;
+    isCollapsed(): boolean;
+    isBackward(): boolean;
+    getCharacterOffsets(): [number, number];
+    extract(): Array<LexicalNode>;
+    insertRawText(text: string): void;
+    insertText(): void;
+    getShape(): GridSelectionShape;
+    getNodes(): Array<LexicalNode>;
+    getTextContent(): string;
+}
+export declare function $isGridSelection(x: unknown): x is GridSelection;
+export declare class RangeSelection implements BaseSelection {
+    anchor: PointType;
+    focus: PointType;
+    dirty: boolean;
+    format: number;
+    _cachedNodes: null | Array<LexicalNode>;
+    constructor(anchor: PointType, focus: PointType, format: number);
+    is(selection: null | RangeSelection | NodeSelection | GridSelection): boolean;
+    isBackward(): boolean;
+    isCollapsed(): boolean;
+    getNodes(): Array<LexicalNode>;
+    setTextNodeRange(anchorNode: TextNode, anchorOffset: number, focusNode: TextNode, focusOffset: number): void;
+    getTextContent(): string;
+    applyDOMRange(range: StaticRange): void;
+    clone(): RangeSelection;
+    toggleFormat(format: TextFormatType): void;
+    hasFormat(type: TextFormatType): boolean;
+    insertRawText(text: string): void;
+    insertText(text: string): void;
+    removeText(): void;
+    formatText(formatType: TextFormatType): void;
+    insertNodes(nodes: Array<LexicalNode>, selectStart?: boolean): boolean;
+    insertParagraph(): void;
+    insertLineBreak(selectStart?: boolean): void;
+    getCharacterOffsets(): [number, number];
+    extract(): Array<LexicalNode>;
+    modify(alter: 'move' | 'extend', isBackward: boolean, granularity: 'character' | 'word' | 'lineboundary'): void;
+    deleteCharacter(isBackward: boolean): void;
+    deleteLine(isBackward: boolean): void;
+    deleteWord(isBackward: boolean): void;
+}
+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 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;
+export declare function $getPreviousSelection(): null | RangeSelection | NodeSelection | GridSelection;
+export declare function $updateElementSelectionOnCreateDeleteNode(selection: RangeSelection, parentNode: LexicalNode, nodeOffset: number, times?: number): void;
+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;

package/LexicalUpdates.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { EditorUpdateOptions, LexicalCommand, LexicalEditor, Transform } from './LexicalEditor';
+import type { SerializedEditorState } from './LexicalEditorState';
+import type { LexicalNode, SerializedLexicalNode } from './LexicalNode';
+import { EditorState } from './LexicalEditorState';
+export declare function isCurrentlyReadOnlyMode(): boolean;
+export declare function errorOnReadOnly(): void;
+export declare function errorOnInfiniteTransforms(): void;
+export declare function getActiveEditorState(): EditorState;
+export declare function getActiveEditor(): LexicalEditor;
+export declare function $applyTransforms(editor: LexicalEditor, node: LexicalNode, transformsCache: Map<string, Array<Transform<LexicalNode>>>): void;
+export declare function $parseSerializedNode(serializedNode: SerializedLexicalNode): LexicalNode;
+export declare function parseEditorState(serializedEditorState: SerializedEditorState, editor: LexicalEditor, updateFn: void | (() => void)): EditorState;
+export declare function readEditorState<V>(editorState: EditorState, callbackFn: () => V): V;
+export declare function commitPendingUpdates(editor: LexicalEditor): void;
+export declare function triggerListeners(type: 'update' | 'root' | 'decorator' | 'textcontent' | 'readonly', editor: LexicalEditor, isCurrentlyEnqueuingUpdates: boolean, ...payload: unknown[]): void;
+export declare function triggerCommandListeners<P>(editor: LexicalEditor, type: LexicalCommand<P>, payload: P): boolean;
+export declare function updateEditor(editor: LexicalEditor, updateFn: () => void, options?: EditorUpdateOptions): void;
+export declare function internalGetActiveEditor(): null | LexicalEditor;