lexical 0.3.5 → 0.3.8

package/LexicalCommands.d.ts

@@ -12,8 +12,8 @@ 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 CONTROLLED_TEXT_INSERTION_COMMAND: LexicalCommand<InputEvent | string>;
+export declare const PASTE_COMMAND: LexicalCommand<ClipboardEvent | InputEvent>;
 export declare const REMOVE_TEXT_COMMAND: LexicalCommand<void>;
 export declare const DELETE_WORD_COMMAND: LexicalCommand<boolean>;
 export declare const DELETE_LINE_COMMAND: LexicalCommand<boolean>;
@@ -39,8 +39,8 @@ 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 COPY_COMMAND: LexicalCommand<ClipboardEvent | KeyboardEvent>;
+export declare const CUT_COMMAND: LexicalCommand<ClipboardEvent | KeyboardEvent>;
 export declare const CLEAR_EDITOR_COMMAND: LexicalCommand<void>;
 export declare const CLEAR_HISTORY_COMMAND: LexicalCommand<void>;
 export declare const CAN_REDO_COMMAND: LexicalCommand<boolean>;

package/LexicalConstants.d.ts

@@ -6,7 +6,7 @@
  *
  */
 import type { ElementFormatType } from './nodes/LexicalElementNode';
-import type { TextFormatType, TextModeType } from './nodes/LexicalTextNode';
+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;
@@ -23,6 +23,7 @@ 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_ALL_FORMATTING: number;
 export declare const IS_DIRECTIONLESS = 1;
 export declare const IS_UNMERGEABLE: number;
 export declare const IS_ALIGN_LEFT = 1;
@@ -35,8 +36,9 @@ 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, number>;
-export declare const ELEMENT_TYPE_TO_FORMAT: Omit<Record<ElementFormatType, number>, ''>;
+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

@@ -7,8 +7,10 @@
  */
 import type { EditorState, SerializedEditorState } from './LexicalEditorState';
 import type { DOMConversion, LexicalNode, NodeKey } from './LexicalNode';
-import type { Klass } from 'shared/types';
 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;
@@ -29,7 +31,11 @@ export declare type EditorUpdateOptions = {
 export declare type EditorSetOptions = {
     tag?: string;
 };
+export declare type EditorFocusOptions = {
+    defaultSelection?: 'rootStart' | 'rootEnd';
+};
 export declare type EditorThemeClasses = {
+    characterLimit?: EditorThemeClassName;
     code?: EditorThemeClassName;
     codeHighlight?: Record<string, EditorThemeClassName>;
     hashtag?: EditorThemeClassName;
@@ -72,11 +78,7 @@ export declare type EditorThemeClasses = {
         base?: EditorThemeClassName;
         focus?: EditorThemeClassName;
     };
-    [key: string]: EditorThemeClassName | TextNodeThemeClasses | {
-        [key: string]: Array<EditorThemeClassName> | EditorThemeClassName | TextNodeThemeClasses | {
-            [key: string]: EditorThemeClassName;
-        };
-    };
+    [key: string]: any;
 };
 export declare type EditorConfig = {
     disableEvents?: boolean;
@@ -88,7 +90,7 @@ export declare type RegisteredNode = {
     klass: Klass<LexicalNode>;
     transforms: Set<Transform<LexicalNode>>;
 };
-export declare type Transform<T> = (node: T) => void;
+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>>;
@@ -101,7 +103,7 @@ export declare type UpdateListener = (arg0: {
     prevEditorState: EditorState;
     tags: Set<string>;
 }) => void;
-export declare type DecoratorListener<T = unknown> = (decorator: Record<NodeKey, T>) => 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;
@@ -113,7 +115,28 @@ 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> = Readonly<Record<string, unknown>>;
+export declare type LexicalCommand<TPayload> = Record<string, never>;
+/**
+ * Type helper for extracting the payload type from a command.
+ *
+ * @example
+ * ```ts
+ * const MY_COMMAND = createCommand<SomeType>();
+ *
+ * // ...
+ *
+ * editor.registerCommand(MY_COMMAND, payload => {
+ *   // Type of `payload` is inferred here. But lets say we want to extract a function to delegate to
+ *   handleMyCommand(editor, payload);
+ *   return true;
+ * });
+ *
+ * function handleMyCommand(editor: LexicalEditor, payload: CommandPayloadType<typeof MY_COMMAND>) {
+ *   // `payload` is of type `SomeType`, extracted from the command.
+ * }
+ * ```
+ */
+export declare type CommandPayloadType<TCommand extends LexicalCommand<unknown>> = TCommand extends LexicalCommand<infer TPayload> ? TPayload : never;
 declare type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<unknown>>>>;
 declare type Listeners = {
     decorator: Set<DecoratorListener>;
@@ -151,7 +174,7 @@ export declare class LexicalEditor {
     _compositionKey: null | NodeKey;
     _deferred: Array<() => void>;
     _keyToDOMMap: Map<NodeKey, HTMLElement>;
-    _updates: Array<[() => void, EditorUpdateOptions]>;
+    _updates: Array<[() => void, EditorUpdateOptions | undefined]>;
     _updating: boolean;
     _listeners: Listeners;
     _commands: Commands;
@@ -181,7 +204,7 @@ export declare class LexicalEditor {
     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;
+    dispatchCommand<TCommand extends LexicalCommand<unknown>, TPayload extends CommandPayloadType<TCommand>>(type: TCommand, payload: TPayload): boolean;
     getDecorators<T>(): Record<NodeKey, T>;
     getRootElement(): null | HTMLElement;
     getKey(): string;
@@ -191,7 +214,7 @@ export declare class LexicalEditor {
     setEditorState(editorState: EditorState, options?: EditorSetOptions): void;
     parseEditorState(maybeStringifiedEditorState: string | SerializedEditorState, updateFn?: () => void): EditorState;
     update(updateFn: () => void, options?: EditorUpdateOptions): void;
-    focus(callbackFn?: () => void): void;
+    focus(callbackFn?: () => void, options?: EditorFocusOptions): void;
     blur(): void;
     isReadOnly(): boolean;
     setReadOnly(readOnly: boolean): void;

package/LexicalNode.d.ts

@@ -15,13 +15,13 @@ export declare type SerializedLexicalNode = {
 };
 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 = {
-    conversion: DOMConversionFn;
+export declare type DOMConversion<T extends HTMLElement = HTMLElement> = {
+    conversion: DOMConversionFn<T>;
     priority: 0 | 1 | 2 | 3 | 4;
 };
-export declare type DOMConversionFn = (element: Node, parent?: Node) => DOMConversionOutput;
-export declare type DOMChildConversion = (lexicalNode: LexicalNode, parentLexicalNode: LexicalNode | null) => LexicalNode | null | void;
-export declare type DOMConversionMap = Record<NodeName, (node: Node) => DOMConversion | null>;
+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>;
@@ -36,7 +36,7 @@ export declare type NodeKey = string;
 export declare class LexicalNode {
     [x: string]: any;
     __type: string;
-    __key: NodeKey;
+    __key: string;
     __parent: null | NodeKey;
     static getType(): string;
     static clone(_data: unknown): LexicalNode;
@@ -50,7 +50,7 @@ export declare class LexicalNode {
     getParentOrThrow<T extends ElementNode>(): T;
     getTopLevelElement(): ElementNode | this | null;
     getTopLevelElementOrThrow(): ElementNode | this;
-    getParents<T extends ElementNode>(): Array<T>;
+    getParents(): Array<ElementNode>;
     getParentKeys(): Array<NodeKey>;
     getPreviousSibling<T extends LexicalNode>(): T | null;
     getPreviousSiblings<T extends LexicalNode>(): Array<T>;

package/LexicalSelection.d.ts

@@ -14,9 +14,9 @@ import { TextNode } from '.';
 export declare type TextPointType = {
     _selection: RangeSelection | GridSelection;
     getNode: () => TextNode;
-    is: (PointType: any) => boolean;
+    is: (point: PointType) => boolean;
     isAtNodeEnd: () => boolean;
-    isBefore: (PointType: any) => boolean;
+    isBefore: (point: PointType) => boolean;
     key: NodeKey;
     offset: number;
     set: (key: NodeKey, offset: number, type: 'text' | 'element') => void;
@@ -25,9 +25,9 @@ export declare type TextPointType = {
 export declare type ElementPointType = {
     _selection: RangeSelection | GridSelection;
     getNode: () => ElementNode;
-    is: (PointType: any) => boolean;
+    is: (point: PointType) => boolean;
     isAtNodeEnd: () => boolean;
-    isBefore: (PointType: any) => boolean;
+    isBefore: (point: PointType) => boolean;
     key: NodeKey;
     offset: number;
     set: (key: NodeKey, offset: number, type: 'text' | 'element') => void;
@@ -38,7 +38,7 @@ export declare class Point {
     key: NodeKey;
     offset: number;
     type: 'text' | 'element';
-    _selection: RangeSelection | GridSelection;
+    _selection: RangeSelection | GridSelection | null;
     constructor(key: NodeKey, offset: number, type: 'text' | 'element');
     is(point: PointType): boolean;
     isBefore(b: PointType): boolean;
@@ -84,7 +84,7 @@ export declare class GridSelection implements BaseSelection {
     anchor: PointType;
     focus: PointType;
     dirty: boolean;
-    _cachedNodes: Array<LexicalNode>;
+    _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;

package/LexicalUtils.d.ts

@@ -5,14 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { LexicalCommand, MutatedNodes, MutationListeners, NodeMutation, RegisteredNode, RegisteredNodes } from './LexicalEditor';
+import type { CommandPayloadType, EditorThemeClasses, Klass, 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 { DecoratorNode, ElementNode, LineBreakNode } from '.';
 import { LexicalEditor } from './LexicalEditor';
 export declare const emptyFunction: () => void;
 export declare function resetRandomKey(): void;
@@ -27,7 +26,7 @@ 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 $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 internalMarkNodeAsDirty(node: LexicalNode): void;
@@ -38,7 +37,7 @@ export declare function $getNodeByKey<T extends LexicalNode>(key: NodeKey, _edit
 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 getEditorStateTextContent(editorState: EditorState): string;
 export declare function markAllNodesAsDirty(editor: LexicalEditor, type: string): void;
 export declare function $getRoot(): RootNode;
 export declare function internalGetRoot(editorState: EditorState): RootNode;
@@ -82,12 +81,12 @@ 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 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 $nodesOfType<T extends LexicalNode>(klass: Klass<T>): Array<LexicalNode>;
 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 dispatchCommand<TCommand extends LexicalCommand<unknown>, TPayload extends CommandPayloadType<TCommand>>(editor: LexicalEditor, type: TCommand, payload: TPayload): 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;

package/LexicalVersion.d.ts

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

package/index.d.ts

@@ -5,7 +5,7 @@
  * 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 { CommandListenerPriority, CommandPayloadType, EditorConfig, EditorThemeClasses, IntentionallyMarkedAsDirtyElement, Klass, 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';

package/nodes/LexicalElementNode.d.ts

@@ -66,6 +66,6 @@ export declare class ElementNode extends LexicalNode {
     canInsertTextAfter(): boolean;
     isInline(): boolean;
     canMergeWith(node: ElementNode): boolean;
-    extractWithChild(child: LexicalNode, selection: RangeSelection | NodeSelection | GridSelection, destination: 'clone' | 'html'): boolean;
+    extractWithChild(child: LexicalNode, selection: RangeSelection | NodeSelection | GridSelection | null, destination: 'clone' | 'html'): boolean;
 }
 export declare function $isElementNode(node: LexicalNode | null | undefined): node is ElementNode;

package/nodes/LexicalTextNode.d.ts

@@ -18,6 +18,7 @@ export declare type SerializedTextNode = Spread<{
     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 TextMark = {
     end: null | number;
@@ -54,8 +55,8 @@ export declare class TextNode extends LexicalNode {
     static importJSON(serializedNode: SerializedTextNode): TextNode;
     exportJSON(): SerializedTextNode;
     selectionTransform(prevSelection: null | RangeSelection | NodeSelection | GridSelection, nextSelection: RangeSelection): void;
-    setFormat(format: number): this;
-    setDetail(detail: number): this;
+    setFormat(format: TextFormatType | number): this;
+    setDetail(detail: TextDetailType | number): this;
     setStyle(style: string): this;
     toggleFormat(type: TextFormatType): this;
     toggleDirectionless(): this;

package/package.json

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