lexical 0.3.1 → 0.3.4

package/LexicalUtils.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 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 { LexicalCommand, MutatedNodes, MutationListeners, NodeMutation, RegisteredNode, RegisteredNodes } from './LexicalEditor';
+import type { EditorState } from './LexicalEditorState';
+import type { LexicalNode, NodeKey } from './LexicalNode';
+import type { GridSelection, NodeSelection, PointType, RangeSelection } from './LexicalSelection';
+import type { RootNode } from './nodes/LexicalRootNode';
+import type { TextFormatType, TextNode } from './nodes/LexicalTextNode';
+import type { Klass } from 'shared/types';
+import { ElementNode } from '.';
+import { LexicalEditor } from './LexicalEditor';
+export declare const emptyFunction: () => void;
+export declare function resetRandomKey(): void;
+export declare function generateRandomKey(): string;
+export declare function getRegisteredNodeOrThrow(editor: LexicalEditor, nodeType: string): RegisteredNode;
+export declare const isArray: (arg: any) => arg is any[];
+export declare const scheduleMicroTask: (fn: () => void) => void;
+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 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): boolean;
+export declare function $setNodeKey(node: LexicalNode, existingKey: NodeKey | null | undefined): void;
+export declare function removeFromParent(writableNode: LexicalNode): void;
+export declare function internalMarkNodeAsDirty(node: LexicalNode): void;
+export declare function internalMarkSiblingsAsDirty(node: LexicalNode): void;
+export declare function $setCompositionKey(compositionKey: null | NodeKey): void;
+export declare function $getCompositionKey(): null | NodeKey;
+export declare function $getNodeByKey<T extends LexicalNode>(key: NodeKey, _editorState?: EditorState): T | null;
+export declare function getNodeFromDOMNode(dom: Node, editorState?: EditorState): LexicalNode | null;
+export declare function $getNearestNodeFromDOMNode(startingDOM: Node, editorState?: EditorState): LexicalNode | null;
+export declare function cloneDecorators(editor: LexicalEditor): Record<NodeKey, unknown>;
+export declare function getEditorStateTextContent(editorState: any): string;
+export declare function markAllNodesAsDirty(editor: LexicalEditor, type: string): void;
+export declare function $getRoot(): RootNode;
+export declare function internalGetRoot(editorState: EditorState): RootNode;
+export declare function $setSelection(selection: null | RangeSelection | NodeSelection | GridSelection): void;
+export declare function $flushMutations(): void;
+export declare function getNodeFromDOM(dom: Node): null | LexicalNode;
+export declare function getTextNodeOffset(node: TextNode, moveSelectionToEnd: boolean): number;
+export declare function doesContainGrapheme(str: string): boolean;
+export declare function getEditorsToPropagate(editor: LexicalEditor): Array<LexicalEditor>;
+export declare function createUID(): string;
+export declare function $updateSelectedTextFromDOM(editor: LexicalEditor, isCompositionEnd: boolean, data?: string): void;
+export declare function $updateTextNodeFromDOMContent(textNode: TextNode, textContent: string, anchorOffset: null | number, focusOffset: null | number, compositionEnd: boolean): void;
+export declare function $shouldPreventDefaultAndInsertText(selection: RangeSelection, text: string): boolean;
+export declare function isTab(keyCode: number, altKey: boolean, ctrlKey: boolean, metaKey: boolean): boolean;
+export declare function isBold(keyCode: number, altKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isItalic(keyCode: number, altKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isUnderline(keyCode: number, altKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isParagraph(keyCode: number, shiftKey: boolean): boolean;
+export declare function isLineBreak(keyCode: number, shiftKey: boolean): boolean;
+export declare function isOpenLineBreak(keyCode: number, ctrlKey: boolean): boolean;
+export declare function isDeleteWordBackward(keyCode: number, altKey: boolean, ctrlKey: boolean): boolean;
+export declare function isDeleteWordForward(keyCode: number, altKey: boolean, ctrlKey: boolean): boolean;
+export declare function isDeleteLineBackward(keyCode: number, metaKey: boolean): boolean;
+export declare function isDeleteLineForward(keyCode: number, metaKey: boolean): boolean;
+export declare function isDeleteBackward(keyCode: number, altKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isDeleteForward(keyCode: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isUndo(keyCode: number, shiftKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isRedo(keyCode: number, shiftKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isCopy(keyCode: number, shiftKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isCut(keyCode: number, shiftKey: boolean, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isMoveBackward(keyCode: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isMoveToStart(keyCode: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isMoveForward(keyCode: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isMoveToEnd(keyCode: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isMoveUp(keyCode: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isMoveDown(keyCode: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isModifier(ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
+export declare function isSpace(keyCode: number): boolean;
+export declare function controlOrMeta(metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function isReturn(keyCode: number): boolean;
+export declare function isBackspace(keyCode: number): boolean;
+export declare function isEscape(keyCode: number): boolean;
+export declare function isDelete(keyCode: number): boolean;
+export declare function getCachedClassNameArray<T>(classNamesTheme: T, 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 isFirefoxClipboardEvents(): boolean;
+export declare function dispatchCommand<P>(editor: LexicalEditor, type: LexicalCommand<P>, payload: P): boolean;
+export declare function $textContentRequiresDoubleLinebreakAtEnd(node: ElementNode): boolean;
+export declare function getElementByKeyOrThrow(editor: LexicalEditor, key: NodeKey): HTMLElement;
+export declare function scrollIntoViewIfNeeded(editor: LexicalEditor, anchor: PointType, rootElement: HTMLElement, tags: Set<string>): void;
+export declare function $hasUpdateTag(tag: string): boolean;
+export declare function $addUpdateTag(tag: string): void;

package/LexicalVersion.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ *
+ */
+export declare const VERSION = "0.3.4";

package/README.md

@@ -37,6 +37,7 @@ An editor instance can be created from the `lexical` package and accepts an opti
 import {createEditor} from 'lexical';
 
 const config = {
+  namespace: 'MyEditor',
   theme: {
     ...
   },

package/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ *
+ */
+export type { CommandListenerPriority, EditorConfig, EditorThemeClasses, IntentionallyMarkedAsDirtyElement, LexicalCommand, LexicalEditor, NodeMutation, ReadOnlyListener, 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';
+export type { ElementFormatType, SerializedElementNode, } from './nodes/LexicalElementNode';
+export type { SerializedGridCellNode } from './nodes/LexicalGridCellNode';
+export type { SerializedRootNode } from './nodes/LexicalRootNode';
+export type { SerializedTextNode, TextFormatType, TextModeType, } from './nodes/LexicalTextNode';
+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 { $parseSerializedNode } from './LexicalUpdates';
+export { $getDecoratorNode, $getNearestNodeFromDOMNode, $getNodeByKey, $getRoot, $isLeafNode, $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 { $createLineBreakNode, $isLineBreakNode, LineBreakNode, } from './nodes/LexicalLineBreakNode';
+export { $createParagraphNode, $isParagraphNode, ParagraphNode, } from './nodes/LexicalParagraphNode';
+export { $isRootNode, RootNode } from './nodes/LexicalRootNode';
+export { $createTextNode, $isTextNode, TextNode } from './nodes/LexicalTextNode';

package/nodes/LexicalDecoratorNode.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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';
+import { EditorConfig } from 'lexical';
+import { LexicalNode } from '../LexicalNode';
+export declare class DecoratorNode<T> extends LexicalNode {
+    constructor(key?: NodeKey);
+    decorate(editor: LexicalEditor, config: EditorConfig): T;
+    isIsolated(): boolean;
+    isTopLevel(): boolean;
+}
+export declare function $isDecoratorNode<T>(node: LexicalNode | null | undefined): node is DecoratorNode<T>;

package/nodes/LexicalElementNode.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 { NodeKey, SerializedLexicalNode } from '../LexicalNode';
+import type { GridSelection, NodeSelection, RangeSelection } from '../LexicalSelection';
+import type { Spread } from 'lexical';
+import { TextNode } from '../';
+import { LexicalNode } from '../LexicalNode';
+export declare type SerializedElementNode = Spread<{
+    children: Array<SerializedLexicalNode>;
+    direction: 'ltr' | 'rtl' | null;
+    format: ElementFormatType;
+    indent: number;
+}, SerializedLexicalNode>;
+export declare type ElementFormatType = 'left' | 'center' | 'right' | 'justify' | '';
+export declare class ElementNode extends LexicalNode {
+    __children: Array<NodeKey>;
+    __format: number;
+    __indent: number;
+    __dir: 'ltr' | 'rtl' | null;
+    constructor(key?: NodeKey);
+    getFormat(): number;
+    getFormatType(): ElementFormatType;
+    getIndent(): number;
+    getChildren<T extends LexicalNode>(): Array<T>;
+    getChildrenKeys(): Array<NodeKey>;
+    getChildrenSize(): number;
+    isEmpty(): boolean;
+    isDirty(): boolean;
+    isLastChild(): boolean;
+    getAllTextNodes(includeInert?: boolean): 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;
+    getChildAtIndex<T extends LexicalNode>(index: number): null | T;
+    getTextContent(includeInert?: boolean, includeDirectionless?: false): string;
+    getDirection(): 'ltr' | 'rtl' | null;
+    hasFormat(type: ElementFormatType): boolean;
+    select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+    selectStart(): RangeSelection;
+    selectEnd(): RangeSelection;
+    clear(): this;
+    append(...nodesToAppend: LexicalNode[]): this;
+    setDirection(direction: 'ltr' | 'rtl' | null): this;
+    setFormat(type: ElementFormatType): this;
+    setIndent(indentLevel: number): this;
+    splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): this;
+    exportJSON(): SerializedElementNode;
+    insertNewAfter(selection: RangeSelection): null | LexicalNode;
+    canInsertTab(): boolean;
+    canIndent(): boolean;
+    collapseAtStart(selection: RangeSelection): boolean;
+    excludeFromCopy(destination?: 'clone' | 'html'): boolean;
+    canExtractContents(): boolean;
+    canReplaceWith(replacement: LexicalNode): boolean;
+    canInsertAfter(node: LexicalNode): boolean;
+    canBeEmpty(): boolean;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    isInline(): boolean;
+    canMergeWith(node: ElementNode): boolean;
+    extractWithChild(child: LexicalNode, selection: RangeSelection | NodeSelection | GridSelection, destination: 'clone' | 'html'): boolean;
+}
+export declare function $isElementNode(node: LexicalNode | null | undefined): node is ElementNode;

package/nodes/LexicalGridCellNode.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { LexicalNode, NodeKey, SerializedElementNode, Spread } from 'lexical';
+import { ElementNode } from './LexicalElementNode';
+export declare type SerializedGridCellNode = Spread<{
+    colSpan: number;
+}, SerializedElementNode>;
+export declare class GridCellNode extends ElementNode {
+    __colSpan: number;
+    constructor(colSpan: number, key?: NodeKey);
+    exportJSON(): SerializedGridCellNode;
+}
+export declare function $isGridCellNode(node: GridCellNode | LexicalNode | null | undefined): node is GridCellNode;

package/nodes/LexicalGridNode.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 { LexicalNode } from '../LexicalNode';
+import { ElementNode } from './LexicalElementNode';
+export declare class GridNode extends ElementNode {
+}
+export declare function $isGridNode(node: LexicalNode | null | undefined): node is GridNode;

package/nodes/LexicalGridRowNode.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 { LexicalNode } from '../LexicalNode';
+import { ElementNode } from './LexicalElementNode';
+export declare class GridRowNode extends ElementNode {
+}
+export declare function $isGridRowNode(node: LexicalNode | null | undefined): node is GridRowNode;

package/nodes/LexicalLineBreakNode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { DOMConversionMap, NodeKey, SerializedLexicalNode } from '../LexicalNode';
+import type { Spread } from 'lexical';
+import { LexicalNode } from '../LexicalNode';
+export declare type SerializedLineBreakNode = Spread<{
+    type: 'linebreak';
+}, SerializedLexicalNode>;
+export declare class LineBreakNode extends LexicalNode {
+    static getType(): string;
+    static clone(node: LineBreakNode): LineBreakNode;
+    constructor(key?: NodeKey);
+    getTextContent(): '\n';
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedLineBreakNode: SerializedLineBreakNode): LineBreakNode;
+    exportJSON(): SerializedLexicalNode;
+}
+export declare function $createLineBreakNode(): LineBreakNode;
+export declare function $isLineBreakNode(node: LexicalNode | null | undefined): node is LineBreakNode;

package/nodes/LexicalParagraphNode.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { DOMConversionMap, DOMExportOutput, LexicalNode } from '../LexicalNode';
+import type { SerializedElementNode } from './LexicalElementNode';
+import type { Spread } from 'lexical';
+import { ElementNode } from './LexicalElementNode';
+export declare type SerializedParagraphNode = Spread<{
+    type: 'paragraph';
+    version: 1;
+}, SerializedElementNode>;
+export declare class ParagraphNode extends ElementNode {
+    static getType(): string;
+    static clone(node: ParagraphNode): ParagraphNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: ParagraphNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    static importJSON(serializedNode: SerializedParagraphNode): ParagraphNode;
+    exportJSON(): SerializedElementNode;
+    insertNewAfter(): ParagraphNode;
+    collapseAtStart(): boolean;
+}
+export declare function $createParagraphNode(): ParagraphNode;
+export declare function $isParagraphNode(node: LexicalNode | null | undefined): node is ParagraphNode;

package/nodes/LexicalRootNode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { LexicalNode } from '../LexicalNode';
+import type { SerializedElementNode } from './LexicalElementNode';
+import { ElementNode } from './LexicalElementNode';
+export declare type SerializedRootNode = SerializedElementNode;
+export declare class RootNode extends ElementNode {
+    __cachedText: null | string;
+    static getType(): string;
+    static clone(): RootNode;
+    constructor();
+    getTopLevelElementOrThrow(): never;
+    getTextContent(includeInert?: boolean, includeDirectionless?: false): string;
+    remove(): never;
+    replace<N = LexicalNode>(node: N): never;
+    insertBefore(nodeToInsert: LexicalNode): LexicalNode;
+    insertAfter(nodeToInsert: LexicalNode): LexicalNode;
+    updateDOM(prevNode: RootNode, dom: HTMLElement): false;
+    append(...nodesToAppend: LexicalNode[]): this;
+    static importJSON(serializedNode: SerializedRootNode): RootNode;
+    exportJSON(): SerializedRootNode;
+}
+export declare function $createRootNode(): RootNode;
+export declare function $isRootNode(node: RootNode | LexicalNode | null | undefined): node is RootNode;

package/nodes/LexicalTextNode.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 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 } from '../LexicalEditor';
+import type { DOMConversionMap, NodeKey, SerializedLexicalNode } from '../LexicalNode';
+import type { GridSelection, NodeSelection, RangeSelection } from '../LexicalSelection';
+import type { Spread } from 'lexical';
+import { LexicalNode } from '../LexicalNode';
+export declare type SerializedTextNode = Spread<{
+    detail: number;
+    format: number;
+    mode: TextModeType;
+    style: string;
+    text: string;
+}, SerializedLexicalNode>;
+export declare type TextFormatType = 'bold' | 'underline' | 'strikethrough' | 'italic' | 'code' | 'subscript' | 'superscript';
+export declare type TextModeType = 'normal' | 'token' | 'segmented' | 'inert';
+export declare type TextMark = {
+    end: null | number;
+    id: string;
+    start: null | number;
+};
+export declare type TextMarks = Array<TextMark>;
+export declare class TextNode extends LexicalNode {
+    __text: string;
+    __format: number;
+    __style: string;
+    __mode: 0 | 1 | 2 | 3;
+    __detail: number;
+    static getType(): string;
+    static clone(node: TextNode): TextNode;
+    constructor(text: string, key?: NodeKey);
+    getFormat(): number;
+    getDetail(): number;
+    getMode(): TextModeType;
+    getStyle(): string;
+    isToken(): boolean;
+    isComposing(): boolean;
+    isSegmented(): boolean;
+    isInert(): boolean;
+    isDirectionless(): boolean;
+    isUnmergeable(): boolean;
+    hasFormat(type: TextFormatType): boolean;
+    isSimpleText(): boolean;
+    getTextContent(includeInert?: boolean, includeDirectionless?: false): string;
+    getFormatFlags(type: TextFormatType, alignWithFormat: null | number): number;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: TextNode, dom: HTMLElement, config: EditorConfig): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTextNode): TextNode;
+    exportJSON(): SerializedTextNode;
+    selectionTransform(prevSelection: null | RangeSelection | NodeSelection | GridSelection, nextSelection: RangeSelection): void;
+    setFormat(format: number): this;
+    setDetail(detail: number): this;
+    setStyle(style: string): this;
+    toggleFormat(type: TextFormatType): this;
+    toggleDirectionless(): this;
+    toggleUnmergeable(): this;
+    setMode(type: TextModeType): this;
+    setTextContent(text: string): this;
+    select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+    spliceText(offset: number, delCount: number, newText: string, moveSelection?: boolean): TextNode;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    splitText(...splitOffsets: Array<number>): Array<TextNode>;
+    mergeWithSibling(target: TextNode): TextNode;
+    isTextEntity(): boolean;
+}
+export declare function $createTextNode(text?: string): TextNode;
+export declare function $isTextNode(node: LexicalNode | null | undefined): node is TextNode;

package/package.json

@@ -9,12 +9,14 @@
     "rich-text"
   ],
   "license": "MIT",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "main": "Lexical.js",
-  "typings": "Lexical.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/lexical",
     "directory": "packages/lexical"
+  },
+  "devDependencies": {
+    "utility-types": "^3.10.0"
   }
 }