lexical 0.3.6 → 0.3.9

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

@@ -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;

package/LexicalEditor.d.ts

@@ -31,6 +31,9 @@ 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;
@@ -103,7 +106,10 @@ export declare type UpdateListener = (arg0: {
 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 MutationListener = (nodes: Map<NodeKey, NodeMutation>, payload: {
+    updateTags: Set<string>;
+    dirtyLeaves: Set<string>;
+}) => 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;
@@ -112,7 +118,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 = never> = 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>;
@@ -180,7 +207,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;
@@ -190,7 +217,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/LexicalUtils.d.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { EditorThemeClasses, Klass, 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';
@@ -48,7 +48,7 @@ export declare function getTextNodeOffset(node: TextNode, moveSelectionToEnd: bo
 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 $updateSelectedTextFromDOM(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;
@@ -68,12 +68,12 @@ export declare function isUndo(keyCode: number, shiftKey: boolean, metaKey: bool
 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 isMoveBackward(keyCode: number, ctrlKey: 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 isMoveForward(keyCode: number, ctrlKey: 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 isMoveUp(keyCode: number, ctrlKey: boolean, metaKey: boolean): boolean;
+export declare function isMoveDown(keyCode: number, ctrlKey: 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;
@@ -86,9 +86,10 @@ export declare function setMutatedNode(mutatedNodes: MutatedNodes, registeredNod
 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;
 export declare function $hasUpdateTag(tag: string): boolean;
 export declare function $addUpdateTag(tag: string): void;
+export declare function $maybeMoveChildrenSelectionToParent(parentNode: LexicalNode, offset?: number): RangeSelection | NodeSelection | GridSelection | null;

package/LexicalVersion.d.ts

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

package/README.md

@@ -1,6 +1,6 @@
 # `lexical`
 
-Lexical is an extensible JavaScript web text-editor framework with an emphasis on reliability, accessibility and performance. Lexical aims to provide a best-in-class developer experience, so you can easily prototype and build features with confidence. Combined with a highly extensible architecture, Lexical allows developers to create unique text editing experiences that scale in size and functionality.
+Lexical is an extensible JavaScript web text-editor framework with an emphasis on reliability, accessibility, and performance. Lexical aims to provide a best-in-class developer experience, so you can easily prototype and build features with confidence. Combined with a highly extensible architecture, Lexical allows developers to create unique text editing experiences that scale in size and functionality.
 
 The core of Lexical is a dependency-free text editor engine that allows for powerful, simple and complex,
 editor implementations to be built on top. Lexical's engine provides three main parts:

package/index.d.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-export type { CommandListenerPriority, EditorConfig, EditorThemeClasses, IntentionallyMarkedAsDirtyElement, Klass, LexicalCommand, LexicalEditor, NodeMutation, ReadOnlyListener, SerializedEditor, Spread, } from './LexicalEditor';
+export type { CommandListenerPriority, CommandPayloadType, EditorConfig, EditorThemeClasses, IntentionallyMarkedAsDirtyElement, Klass, LexicalCommand, LexicalEditor, MutationListener, 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/package.json

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