lexical 0.3.11 → 0.4.0

package/LexicalEditor.d.ts

@@ -111,7 +111,7 @@ export declare type MutationListener = (nodes: Map<NodeKey, NodeMutation>, paylo
     dirtyLeaves: Set<string>;
 }) => void;
 export declare type CommandListener<P> = (payload: P, editor: LexicalEditor) => boolean;
-export declare type ReadOnlyListener = (readOnly: boolean) => void;
+export declare type EditableListener = (editable: 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;
@@ -144,13 +144,13 @@ declare type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<u
 declare type Listeners = {
     decorator: Set<DecoratorListener>;
     mutation: MutationListeners;
-    readonly: Set<ReadOnlyListener>;
+    editable: Set<EditableListener>;
     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 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 DOMConversionCache = Map<string, Array<(node: Node) => DOMConversion | null>>;
@@ -165,7 +165,7 @@ export declare function createEditor(editorConfig?: {
     nodes?: ReadonlyArray<Klass<LexicalNode>>;
     onError?: ErrorHandler;
     parentEditor?: LexicalEditor;
-    readOnly?: boolean;
+    editable?: boolean;
     theme?: EditorThemeClasses;
 }): LexicalEditor;
 export declare class LexicalEditor {
@@ -195,11 +195,12 @@ export declare class LexicalEditor {
     _key: string;
     _onError: ErrorHandler;
     _htmlConversions: DOMConversionCache;
-    _readOnly: boolean;
-    constructor(editorState: EditorState, parentEditor: null | LexicalEditor, nodes: RegisteredNodes, config: EditorConfig, onError: ErrorHandler, htmlConversions: DOMConversionCache, readOnly: boolean);
+    _window: null | Window;
+    _editable: boolean;
+    constructor(editorState: EditorState, parentEditor: null | LexicalEditor, nodes: RegisteredNodes, config: EditorConfig, onError: ErrorHandler, htmlConversions: DOMConversionCache, editable: boolean);
     isComposing(): boolean;
     registerUpdateListener(listener: UpdateListener): () => void;
-    registerReadOnlyListener(listener: ReadOnlyListener): () => void;
+    registerEditableListener(listener: EditableListener): () => void;
     registerDecoratorListener<T>(listener: DecoratorListener<T>): () => void;
     registerTextContentListener(listener: TextContentListener): () => void;
     registerRootListener(listener: RootListener): () => void;
@@ -219,8 +220,8 @@ export declare class LexicalEditor {
     update(updateFn: () => void, options?: EditorUpdateOptions): void;
     focus(callbackFn?: () => void, options?: EditorFocusOptions): void;
     blur(): void;
-    isReadOnly(): boolean;
-    setReadOnly(readOnly: boolean): void;
+    isEditable(): boolean;
+    setEditable(editable: boolean): void;
     toJSON(): SerializedEditor;
 }
 export {};

package/LexicalNode.d.ts

@@ -35,8 +35,11 @@ export declare type DOMExportOutput = {
 export declare type NodeKey = string;
 export declare class LexicalNode {
     [x: string]: any;
+    /** @internal */
     __type: string;
+    /** @internal */
     __key: string;
+    /** @internal */
     __parent: null | NodeKey;
     static getType(): string;
     static clone(_data: unknown): LexicalNode;

package/LexicalUpdates.d.ts

@@ -19,7 +19,7 @@ export declare function $parseSerializedNode(serializedNode: SerializedLexicalNo
 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 triggerListeners(type: 'update' | 'root' | 'decorator' | 'textcontent' | 'editable', 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;

package/LexicalUtils.d.ts

@@ -19,6 +19,8 @@ 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 $isSelectionCapturedInDecorator(node: Node): boolean;
+export declare function isSelectionCapturedInDecoratorInput(anchorDOM: Node): boolean;
 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;
@@ -85,7 +87,7 @@ export declare function getCachedClassNameArray(classNamesTheme: EditorThemeClas
 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<LexicalNode>;
 export declare function $getDecoratorNode(focus: PointType, isBackward: boolean): null | LexicalNode;
-export declare function isFirefoxClipboardEvents(): boolean;
+export declare function isFirefoxClipboardEvents(editor: LexicalEditor): 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;
@@ -93,3 +95,5 @@ export declare function scrollIntoViewIfNeeded(editor: LexicalEditor, anchor: Po
 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;
+export declare function getDefaultView(domElem: HTMLElement): Window | null;
+export declare function getWindow(editor: LexicalEditor): Window;

package/LexicalVersion.d.ts

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

package/index.d.ts

@@ -1,3 +1,4 @@
+/** @module lexical */
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -5,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-export type { CommandListenerPriority, CommandPayloadType, EditorConfig, EditorThemeClasses, IntentionallyMarkedAsDirtyElement, Klass, LexicalCommand, LexicalEditor, MutationListener, NodeMutation, ReadOnlyListener, SerializedEditor, Spread, } from './LexicalEditor';
+export type { CommandListenerPriority, CommandPayloadType, EditableListener, EditorConfig, EditorThemeClasses, IntentionallyMarkedAsDirtyElement, 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';
@@ -25,7 +26,9 @@ 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 type { SerializedLineBreakNode } from './nodes/LexicalLineBreakNode';
 export { $createLineBreakNode, $isLineBreakNode, LineBreakNode, } from './nodes/LexicalLineBreakNode';
+export type { SerializedParagraphNode } from './nodes/LexicalParagraphNode';
 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

@@ -9,6 +9,7 @@ import type { LexicalEditor } from '../LexicalEditor';
 import type { NodeKey } from '../LexicalNode';
 import { EditorConfig } from 'lexical';
 import { LexicalNode } from '../LexicalNode';
+/** @noInheritDoc */
 export declare class DecoratorNode<T> extends LexicalNode {
     constructor(key?: NodeKey);
     decorate(editor: LexicalEditor, config: EditorConfig): T;

package/nodes/LexicalElementNode.d.ts

@@ -17,10 +17,15 @@ export declare type SerializedElementNode = Spread<{
     indent: number;
 }, SerializedLexicalNode>;
 export declare type ElementFormatType = 'left' | 'center' | 'right' | 'justify' | '';
+/** @noInheritDoc */
 export declare class ElementNode extends LexicalNode {
+    /** @internal */
     __children: Array<NodeKey>;
+    /** @internal */
     __format: number;
+    /** @internal */
     __indent: number;
+    /** @internal */
     __dir: 'ltr' | 'rtl' | null;
     constructor(key?: NodeKey);
     getFormat(): number;

package/nodes/LexicalGridCellNode.d.ts

@@ -10,7 +10,9 @@ import { ElementNode } from './LexicalElementNode';
 export declare type SerializedGridCellNode = Spread<{
     colSpan: number;
 }, SerializedElementNode>;
+/** @noInheritDoc */
 export declare class GridCellNode extends ElementNode {
+    /** @internal */
     __colSpan: number;
     constructor(colSpan: number, key?: NodeKey);
     exportJSON(): SerializedGridCellNode;

package/nodes/LexicalLineBreakNode.d.ts

@@ -11,6 +11,7 @@ import { LexicalNode } from '../LexicalNode';
 export declare type SerializedLineBreakNode = Spread<{
     type: 'linebreak';
 }, SerializedLexicalNode>;
+/** @noInheritDoc */
 export declare class LineBreakNode extends LexicalNode {
     static getType(): string;
     static clone(node: LineBreakNode): LineBreakNode;

package/nodes/LexicalParagraphNode.d.ts

@@ -14,6 +14,7 @@ export declare type SerializedParagraphNode = Spread<{
     type: 'paragraph';
     version: 1;
 }, SerializedElementNode>;
+/** @noInheritDoc */
 export declare class ParagraphNode extends ElementNode {
     static getType(): string;
     static clone(node: ParagraphNode): ParagraphNode;

package/nodes/LexicalRootNode.d.ts

@@ -9,7 +9,9 @@ import type { LexicalNode } from '../LexicalNode';
 import type { SerializedElementNode } from './LexicalElementNode';
 import { ElementNode } from './LexicalElementNode';
 export declare type SerializedRootNode = SerializedElementNode;
+/** @noInheritDoc */
 export declare class RootNode extends ElementNode {
+    /** @internal */
     __cachedText: null | string;
     static getType(): string;
     static clone(): RootNode;

package/nodes/LexicalTextNode.d.ts

@@ -26,6 +26,7 @@ export declare type TextMark = {
     start: null | number;
 };
 export declare type TextMarks = Array<TextMark>;
+/** @noInheritDoc */
 export declare class TextNode extends LexicalNode {
     __text: string;
     __format: number;

package/package.json

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