@lexical/react 0.3.3 → 0.3.6

package/LexicalCheckListPlugin.prod.js

@@ -5,10 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict';var e=require("@lexical/list"),g=require("@lexical/react/LexicalComposerContext"),k=require("@lexical/utils"),l=require("lexical"),m=require("react");let n=0;function p(){0===n++&&(document.addEventListener("click",q),document.addEventListener("pointerdown",r));return()=>{0===--n&&(document.removeEventListener("click",q),document.removeEventListener("pointerdown",r))}}
-function t(a,c){let b=a.target;if(b instanceof HTMLElement){var d=b.firstChild;(null==d||"UL"!==d.tagName&&"OL"!==d.tagName)&&(d=b.parentNode)&&"check"===d.__lexicalListType&&(a=a.pageX,d=b.getBoundingClientRect(),("rtl"===b.dir?a<d.right&&a>d.right-20:a>d.left&&a<d.left+20)&&c())}}function q(a){t(a,()=>{let c=u(a.target);null==c||c.isReadOnly()||c.update(()=>{let b=l.$getNearestNodeFromDOMNode(a.target);e.$isListItemNode(b)&&(a.target.focus(),b.toggleChecked())})})}
-function r(a){t(a,()=>{a.preventDefault()})}function u(a){for(;a;){if(a.__lexicalEditor)return a.__lexicalEditor;a=a.parentNode}return null}function v(){let a=document.activeElement;return null!=a&&"LI"===a.tagName&&null!=a.parentNode&&"check"===a.parentNode.__lexicalListType?a:null}
-function w(a,c){let b=c?a.getPreviousSibling():a.getNextSibling();for(;null==b&&e.$isListItemNode(a);)a=a.getParentOrThrow().getParent(),null!=a&&(b=c?a.getPreviousSibling():a.getNextSibling());for(;e.$isListItemNode(b);){a=c?b.getLastChild():b.getFirstChild();if(!e.$isListNode(a))return b;b=c?a.getLastChild():a.getFirstChild()}return null}
-function x(a,c,b){let d=v();null!=d&&c.update(()=>{var f=l.$getNearestNodeFromDOMNode(d);if(e.$isListItemNode(f)&&(f=w(f,b),null!=f)){f.selectStart();let h=c.getElementByKey(f.__key);null!=h&&(a.preventDefault(),setTimeout(()=>{h.focus()},0))}});return!1}
-exports.CheckListPlugin=function(){let [a]=g.useLexicalComposerContext();m.useEffect(()=>k.mergeRegister(a.registerCommand(e.INSERT_CHECK_LIST_COMMAND,()=>{e.insertList(a,"check");return!0},l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ARROW_DOWN_COMMAND,c=>x(c,a,!1),l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ARROW_UP_COMMAND,c=>x(c,a,!0),l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ESCAPE_COMMAND,()=>{if(null!=v()){let c=a.getRootElement();null!=c&&c.focus();return!0}return!1},l.COMMAND_PRIORITY_LOW),
-a.registerCommand(l.KEY_SPACE_COMMAND,c=>{let b=v();return null==b||a.isReadOnly()?!1:(a.update(()=>{let d=l.$getNearestNodeFromDOMNode(b);e.$isListItemNode(d)&&(c.preventDefault(),d.toggleChecked())}),!0)},l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ARROW_LEFT_COMMAND,c=>a.getEditorState().read(()=>{var b=l.$getSelection();if(l.$isRangeSelection(b)&&b.isCollapsed()){var {anchor:d}=b;if((b="element"===d.type)||0===d.offset){d=d.getNode();let f=k.$findMatchingParent(d,h=>l.$isElementNode(h)&&!h.isInline());
-if(e.$isListItemNode(f)&&(b||f.getFirstDescendant()===d)&&(b=a.getElementByKey(f.__key),null!=b&&document.activeElement!==b))return b.focus(),c.preventDefault(),!0}}return!1}),l.COMMAND_PRIORITY_LOW),p()));return null}
+function t(a,d){let b=a.target;if(b instanceof HTMLElement){var c=b.firstChild;null!=c&&c instanceof HTMLElement&&("UL"===c.tagName||"OL"===c.tagName)||(c=b.parentNode)&&"check"===c.__lexicalListType&&(a=a.pageX,c=b.getBoundingClientRect(),("rtl"===b.dir?a<c.right&&a>c.right-20:a>c.left&&a<c.left+20)&&d())}}
+function q(a){t(a,()=>{let d=a.target,b=u(d);null==b||b.isReadOnly()||b.update(()=>{if(a.target){let c=l.$getNearestNodeFromDOMNode(d);e.$isListItemNode(c)&&(d.focus(),c.toggleChecked())}})})}function r(a){t(a,()=>{a.preventDefault()})}function u(a){for(;a;){if(a.__lexicalEditor)return a.__lexicalEditor;a=a.parentNode}return null}function v(){let a=document.activeElement;return null!=a&&"LI"===a.tagName&&null!=a.parentNode&&"check"===a.parentNode.__lexicalListType?a:null}
+function w(a,d){let b=d?a.getPreviousSibling():a.getNextSibling();for(;null==b&&e.$isListItemNode(a);)a=a.getParentOrThrow().getParent(),null!=a&&(b=d?a.getPreviousSibling():a.getNextSibling());for(;e.$isListItemNode(b);){a=d?b.getLastChild():b.getFirstChild();if(!e.$isListNode(a))return b;b=d?a.getLastChild():a.getFirstChild()}return null}
+function x(a,d,b){let c=v();null!=c&&d.update(()=>{var f=l.$getNearestNodeFromDOMNode(c);if(e.$isListItemNode(f)&&(f=w(f,b),null!=f)){f.selectStart();let h=d.getElementByKey(f.__key);null!=h&&(a.preventDefault(),setTimeout(()=>{h.focus()},0))}});return!1}
+exports.CheckListPlugin=function(){let [a]=g.useLexicalComposerContext();m.useEffect(()=>k.mergeRegister(a.registerCommand(e.INSERT_CHECK_LIST_COMMAND,()=>{e.insertList(a,"check");return!0},l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ARROW_DOWN_COMMAND,d=>x(d,a,!1),l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ARROW_UP_COMMAND,d=>x(d,a,!0),l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ESCAPE_COMMAND,()=>{if(null!=v()){let d=a.getRootElement();null!=d&&d.focus();return!0}return!1},l.COMMAND_PRIORITY_LOW),
+a.registerCommand(l.KEY_SPACE_COMMAND,d=>{let b=v();return null==b||a.isReadOnly()?!1:(a.update(()=>{let c=l.$getNearestNodeFromDOMNode(b);e.$isListItemNode(c)&&(d.preventDefault(),c.toggleChecked())}),!0)},l.COMMAND_PRIORITY_LOW),a.registerCommand(l.KEY_ARROW_LEFT_COMMAND,d=>a.getEditorState().read(()=>{var b=l.$getSelection();if(l.$isRangeSelection(b)&&b.isCollapsed()){var {anchor:c}=b;if((b="element"===c.type)||0===c.offset){c=c.getNode();let f=k.$findMatchingParent(c,h=>l.$isElementNode(h)&&!h.isInline());
+if(e.$isListItemNode(f)&&(b||f.getFirstDescendant()===c)&&(b=a.getElementByKey(f.__key),null!=b&&document.activeElement!==b))return b.focus(),d.preventDefault(),!0}}return!1}),l.COMMAND_PRIORITY_LOW),p()));return null}

package/LexicalClearEditorPlugin.d.ts

@@ -5,8 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-type Props = Readonly<{
-  onClear?: () => void;
+declare type Props = Readonly<{
+    onClear?: () => void;
 }>;
-export function ClearEditorPlugin(arg0: Props): JSX.Element | null;
+export declare function ClearEditorPlugin({ onClear }: Props): JSX.Element | null;
+export {};

package/LexicalCollaborationPlugin.d.ts

@@ -5,35 +5,21 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {Provider} from '@lexical/yjs';
-import type {Doc, RelativePosition} from 'yjs';
-
-export type UserState = {
-  anchorPos: null | RelativePosition;
-  focusPos: null | RelativePosition;
-  name: string;
-  color: string;
-  focusing: boolean;
+/// <reference types="react" />
+import type { Doc } from 'yjs';
+import { WebsocketProvider } from 'y-websocket';
+declare type CollaborationContextType = {
+    clientID: number;
+    color: string;
+    name: string;
+    yjsDocMap: Map<string, Doc>;
 };
-export type ProviderAwareness = {
-  getLocalState: () => UserState;
-  setLocalState: (arg0: UserState) => void;
-  getStates: () => Array<UserState>;
-  on: (type: 'update', cb: () => void) => void;
-  off: (type: 'update', cb: () => void) => void;
-};
-type CollaborationContextType = {
-  clientID: number;
-  color: string;
-  name: string;
-  yjsDocMap: Map<string, Doc>;
-};
-export function CollaborationPlugin(arg0: {
-  id: string;
-  providerFactory(id: string, yjsDocMap: Map<string, Doc>): Provider;
-  shouldBootstrap: boolean;
-  username?: string;
-}): JSX.Element | null;
-export declare var CollaborationContext: React.Context<CollaborationContextType>;
-export function useCollaborationContext(): CollaborationContextType;
+export declare function CollaborationPlugin({ id, providerFactory, shouldBootstrap, username, }: {
+    id: string;
+    providerFactory: (id: string, yjsDocMap: Map<string, Doc>) => WebsocketProvider;
+    shouldBootstrap: boolean;
+    username?: string;
+}): JSX.Element;
+export declare const CollaborationContext: React.Context<CollaborationContextType>;
+export declare function useCollaborationContext(username?: string): CollaborationContextType;
+export {};

package/LexicalComposer.d.ts

@@ -5,19 +5,20 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import {Class} from 'utility-types';
-import type {EditorThemeClasses, LexicalEditor, LexicalNode} from 'lexical';
-
-type Props = {
-  initialConfig: {
-    namespace: string;
-    editor__DEPRECATED?: LexicalEditor | null;
-    readOnly?: boolean;
-    nodes?: Array<Class<LexicalNode>>;
-    theme?: EditorThemeClasses;
-    onError: (error: Error, editor: LexicalEditor) => void;
-  };
-  children: JSX.Element | JSX.Element[] | null;
+import type { Klass } from 'lexical';
+import { EditorState, EditorThemeClasses, LexicalEditor, LexicalNode } from 'lexical';
+export declare type InitialEditorStateType = null | string | EditorState | ((editor: LexicalEditor) => void);
+declare type Props = {
+    children: JSX.Element | string | (JSX.Element | string)[];
+    initialConfig: Readonly<{
+        editor__DEPRECATED?: LexicalEditor | null;
+        namespace: string;
+        nodes?: ReadonlyArray<Klass<LexicalNode>>;
+        onError: (error: Error, editor: LexicalEditor) => void;
+        readOnly?: boolean;
+        theme?: EditorThemeClasses;
+        editorState?: InitialEditorStateType;
+    }>;
 };
-export function LexicalComposer(arg0: Props): JSX.Element | null;
+export declare function LexicalComposer({ initialConfig, children }: Props): JSX.Element;
+export {};

package/LexicalComposer.dev.js

@@ -36,6 +36,9 @@ var useLayoutEffect = useLayoutEffectImpl;
  * LICENSE file in the root directory of this source tree.
  *
  */
+const HISTORY_MERGE_OPTIONS = {
+  tag: 'history-merge'
+};
 function LexicalComposer({
   initialConfig,
   children
@@ -46,7 +49,8 @@ function LexicalComposer({
       namespace,
       editor__DEPRECATED: initialEditor,
       nodes,
-      onError
+      onError,
+      editorState: initialEditorState
     } = initialConfig;
     const context = LexicalComposerContext.createLexicalComposerContext(null, theme);
     let editor = initialEditor || null;
@@ -59,6 +63,7 @@ function LexicalComposer({
         readOnly: true,
         theme
       });
+      initializeEditor(newEditor, initialEditorState);
       editor = newEditor;
     }
 
@@ -77,4 +82,37 @@ function LexicalComposer({
   }, children);
 }
 
+function initializeEditor(editor, initialEditorState) {
+  if (initialEditorState === null) {
+    return;
+  } else if (initialEditorState === undefined) ; else if (initialEditorState !== null) {
+    switch (typeof initialEditorState) {
+      case 'string':
+        {
+          const parsedEditorState = editor.parseEditorState(initialEditorState);
+          editor.setEditorState(parsedEditorState, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+
+      case 'object':
+        {
+          editor.setEditorState(initialEditorState, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+
+      case 'function':
+        {
+          editor.update(() => {
+            const root = lexical.$getRoot();
+
+            if (root.isEmpty()) {
+              initialEditorState(editor);
+            }
+          }, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+    }
+  }
+}
+
 exports.LexicalComposer = LexicalComposer;

package/LexicalComposer.js.flow

@@ -8,6 +8,8 @@
  */
 
 import type {EditorThemeClasses, LexicalEditor, LexicalNode} from 'lexical';
+import type {InitialEditorStateType as InitialEditorStatePlainTextType} from '@lexical/plain-text';
+import type {InitialEditorStateType as InitialEditorStateRichTextType} from '@lexical/rich-text';
 
 type Props = {
   initialConfig: $ReadOnly<{
@@ -16,6 +18,9 @@ type Props = {
     namespace: string,
     nodes?: $ReadOnlyArray<Class<LexicalNode>>,
     theme?: EditorThemeClasses,
+    editorState?:
+      | InitialEditorStateRichTextType
+      | InitialEditorStatePlainTextType,
     onError: (error: Error, editor: LexicalEditor) => void,
   }>,
   children: React$Node,

package/LexicalComposer.prod.js

@@ -4,5 +4,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-'use strict';var a=require("@lexical/react/LexicalComposerContext"),e=require("lexical"),k=require("react"),l="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?k.useLayoutEffect:k.useEffect;
-exports.LexicalComposer=function({initialConfig:f,children:m}){let h=k.useMemo(()=>{const {theme:b,namespace:c,editor__DEPRECATED:n,nodes:p,onError:q}=f,r=a.createLexicalComposerContext(null,b);let d=n||null;if(null===d){const g=e.createEditor({namespace:c,nodes:p,onError:t=>q(t,g),readOnly:!0,theme:b});d=g}return[d,r]},[]);l(()=>{let b=f.readOnly,[c]=h;c.setReadOnly(b||!1)},[]);return k.createElement(a.LexicalComposerContext.Provider,{value:h},m)}
+'use strict';var c=require("@lexical/react/LexicalComposerContext"),f=require("lexical"),l=require("react"),m="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?l.useLayoutEffect:l.useEffect;let n={tag:"history-merge"};
+function p(b,a){if(null!==a&&void 0!==a&&null!==a)switch(typeof a){case "string":let d=b.parseEditorState(a);b.setEditorState(d,n);break;case "object":b.setEditorState(a,n);break;case "function":b.update(()=>{f.$getRoot().isEmpty()&&a(b)},n)}}
+exports.LexicalComposer=function({initialConfig:b,children:a}){let d=l.useMemo(()=>{const {theme:e,namespace:g,editor__DEPRECATED:q,nodes:r,onError:t,editorState:u}=b,v=c.createLexicalComposerContext(null,e);let h=q||null;if(null===h){const k=f.createEditor({namespace:g,nodes:r,onError:w=>t(w,k),readOnly:!0,theme:e});p(k,u);h=k}return[h,v]},[]);m(()=>{let e=b.readOnly,[g]=d;g.setReadOnly(e||!1)},[]);return l.createElement(c.LexicalComposerContext.Provider,{value:d},a)}

package/LexicalComposerContext.d.ts

@@ -5,20 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {EditorThemeClasses, LexicalEditor} from 'lexical';
-export type LexicalComposerContextType = {
-  getTheme: () => EditorThemeClasses | null | undefined;
+/// <reference types="react" />
+import type { EditorThemeClasses, LexicalEditor } from 'lexical';
+export declare type LexicalComposerContextType = {
+    getTheme: () => EditorThemeClasses | null | undefined;
 };
-export type LexicalComposerContextWithEditor = [
-  LexicalEditor,
-  LexicalComposerContextType,
+export declare type LexicalComposerContextWithEditor = [
+    LexicalEditor,
+    LexicalComposerContextType
 ];
-export declare var LexicalComposerContext: React.Context<
-  LexicalComposerContextWithEditor | null | undefined
->;
-export function createLexicalComposerContext(
-  parent: LexicalComposerContextWithEditor | null | undefined,
-  theme: EditorThemeClasses | null | undefined,
-): LexicalComposerContextType;
-export function useLexicalComposerContext(): LexicalComposerContextWithEditor;
+export declare const LexicalComposerContext: React.Context<LexicalComposerContextWithEditor | null | undefined>;
+export declare function createLexicalComposerContext(parent: LexicalComposerContextWithEditor | null | undefined, theme: EditorThemeClasses | null | undefined): LexicalComposerContextType;
+export declare function useLexicalComposerContext(): LexicalComposerContextWithEditor;

package/LexicalContentEditable.d.ts

@@ -5,27 +5,28 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-export type Props = Readonly<{
-  ariaActiveDescendantID?: string;
-  ariaAutoComplete?: string;
-  ariaControls?: string;
-  ariaDescribedBy?: string;
-  ariaExpanded?: boolean;
-  ariaLabel?: string;
-  ariaLabelledBy?: string;
-  ariaMultiline?: boolean;
-  ariaOwneeID?: string;
-  ariaRequired?: string;
-  autoCapitalize?: boolean;
-  autoComplete?: boolean;
-  autoCorrect?: boolean;
-  className?: string;
-  readOnly?: boolean;
-  role?: string;
-  style?: StyleSheetList;
-  spellCheck?: boolean;
-  tabIndex?: number;
-  testid?: string;
+import { CSSProperties } from 'react';
+export declare type Props = Readonly<{
+    ariaActiveDescendantID?: string;
+    ariaAutoComplete?: string;
+    ariaControls?: string;
+    ariaDescribedBy?: string;
+    ariaExpanded?: boolean;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaMultiline?: boolean;
+    ariaOwneeID?: string;
+    ariaRequired?: string;
+    autoCapitalize?: boolean;
+    autoComplete?: boolean;
+    autoCorrect?: boolean;
+    className?: string;
+    id?: string;
+    readOnly?: boolean;
+    role?: string;
+    spellCheck?: boolean;
+    style?: CSSProperties;
+    tabIndex?: number;
+    testid?: string;
 }>;
-export function ContentEditable(props: Props): JSX.Element | null;
+export declare function ContentEditable({ ariaActiveDescendantID, ariaAutoComplete, ariaControls, ariaDescribedBy, ariaExpanded, ariaLabel, ariaLabelledBy, ariaMultiline, ariaOwneeID, ariaRequired, autoCapitalize, autoComplete, autoCorrect, className, id, role, spellCheck, style, tabIndex, testid, }: Props): JSX.Element;

package/LexicalContentEditable.dev.js

@@ -79,16 +79,16 @@ function ContentEditable({
     "aria-multiline": ariaMultiline,
     "aria-owns": isReadOnly ? null : ariaOwneeID,
     "aria-required": ariaRequired,
-    autoCapitalize: autoCapitalize !== undefined ? String(autoCapitalize) : null // @ts-ignore This is a valid attribute
+    autoCapitalize: autoCapitalize !== undefined ? String(autoCapitalize) : undefined // @ts-ignore This is a valid attribute
     ,
     autoComplete: autoComplete,
-    autoCorrect: autoCorrect !== undefined ? String(autoCorrect) : null,
+    autoCorrect: autoCorrect !== undefined ? String(autoCorrect) : undefined,
     className: className,
     contentEditable: !isReadOnly,
     "data-testid": testid,
     id: id,
     ref: ref,
-    role: isReadOnly ? null : role,
+    role: isReadOnly ? undefined : role,
     spellCheck: spellCheck,
     style: style,
     tabIndex: tabIndex

package/LexicalContentEditable.prod.js

@@ -6,4 +6,4 @@
  */
 'use strict';var b=require("@lexical/react/LexicalComposerContext"),k=require("react"),l="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?k.useLayoutEffect:k.useEffect;
 exports.ContentEditable=function({ariaActiveDescendantID:m,ariaAutoComplete:n,ariaControls:p,ariaDescribedBy:q,ariaExpanded:r,ariaLabel:t,ariaLabelledBy:u,ariaMultiline:v,ariaOwneeID:w,ariaRequired:x,autoCapitalize:e,autoComplete:y,autoCorrect:f,className:z,id:A,role:g="textbox",spellCheck:B=!0,style:C,tabIndex:D,testid:E}){let [c]=b.useLexicalComposerContext(),[a,h]=k.useState(!0),F=k.useCallback(d=>{c.setRootElement(d)},[c]);l(()=>{h(c.isReadOnly());return c.registerReadOnlyListener(d=>{h(d)})},
-[c]);return k.createElement("div",{"aria-activedescendant":a?null:m,"aria-autocomplete":a?null:n,"aria-controls":a?null:p,"aria-describedby":q,"aria-expanded":a?null:"combobox"===g?!!r:null,"aria-label":t,"aria-labelledby":u,"aria-multiline":v,"aria-owns":a?null:w,"aria-required":x,autoCapitalize:void 0!==e?String(e):null,autoComplete:y,autoCorrect:void 0!==f?String(f):null,className:z,contentEditable:!a,"data-testid":E,id:A,ref:F,role:a?null:g,spellCheck:B,style:C,tabIndex:D})}
+[c]);return k.createElement("div",{"aria-activedescendant":a?null:m,"aria-autocomplete":a?null:n,"aria-controls":a?null:p,"aria-describedby":q,"aria-expanded":a?null:"combobox"===g?!!r:null,"aria-label":t,"aria-labelledby":u,"aria-multiline":v,"aria-owns":a?null:w,"aria-required":x,autoCapitalize:void 0!==e?String(e):void 0,autoComplete:y,autoCorrect:void 0!==f?String(f):void 0,className:z,contentEditable:!a,"data-testid":E,id:A,ref:F,role:a?void 0:g,spellCheck:B,style:C,tabIndex:D})}

package/LexicalDecoratorBlockNode.d.ts

@@ -5,28 +5,17 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {
-  ElementFormatType,
-  LexicalNode,
-  NodeKey,
-  SerializedLexicalNode,
-} from 'lexical';
-
-import {DecoratorNode} from 'lexical';
-
-export type SerializedDecoratorBlockNode = SerializedLexicalNode & {
-  format: ElementFormatType;
-};
-
-declare class DecoratorBlockNode<T> extends DecoratorNode<T> {
-  __format: ElementFormatType;
-  constructor(format?: ElementFormatType | null, key?: NodeKey);
-  createDOM(): HTMLElement;
-  setFormat(format: ElementFormatType): void;
-  exportJSON(): SerializedDecoratorBlockNode;
+import type { ElementFormatType, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+import { DecoratorNode } from 'lexical';
+export declare type SerializedDecoratorBlockNode = Spread<{
+    format: ElementFormatType;
+}, SerializedLexicalNode>;
+export declare class DecoratorBlockNode extends DecoratorNode<JSX.Element> {
+    __format: ElementFormatType;
+    constructor(format?: ElementFormatType, key?: NodeKey);
+    exportJSON(): SerializedDecoratorBlockNode;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    setFormat(format: ElementFormatType): void;
 }
-
-declare function $isDecoratorBlockNode<T>(
-  node: LexicalNode,
-): node is DecoratorBlockNode<T>;
+export declare function $isDecoratorBlockNode(node: LexicalNode | null | undefined): node is DecoratorBlockNode;

package/LexicalDecoratorBlockNode.dev.js

@@ -18,7 +18,7 @@ var lexical = require('lexical');
 class DecoratorBlockNode extends lexical.DecoratorNode {
   constructor(format, key) {
     super(key);
-    this.__format = format;
+    this.__format = format || '';
   }
 
   exportJSON() {

package/LexicalDecoratorBlockNode.prod.js

@@ -4,4 +4,4 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-'use strict';var b=require("lexical");class c extends b.DecoratorNode{constructor(a,d){super(d);this.__format=a}exportJSON(){return{format:this.__format||"",type:"decorator-block",version:1}}createDOM(){return document.createElement("div")}updateDOM(){return!1}setFormat(a){this.getWritable().__format=a}}exports.$isDecoratorBlockNode=function(a){return a instanceof c};exports.DecoratorBlockNode=c
+'use strict';var b=require("lexical");class c extends b.DecoratorNode{constructor(a,d){super(d);this.__format=a||""}exportJSON(){return{format:this.__format||"",type:"decorator-block",version:1}}createDOM(){return document.createElement("div")}updateDOM(){return!1}setFormat(a){this.getWritable().__format=a}}exports.$isDecoratorBlockNode=function(a){return a instanceof c};exports.DecoratorBlockNode=c

package/LexicalHashtagPlugin.d.ts

@@ -5,5 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-export function HashtagPlugin(): JSX.Element | null;
+export declare function HashtagPlugin(): JSX.Element | null;

package/LexicalHistoryPlugin.d.ts

@@ -5,26 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {
-  EditorState,
-  GridSelection,
-  LexicalEditor,
-  NodeSelection,
-  RangeSelection,
-} from 'lexical';
-
-export type HistoryStateEntry = {
-  editor: LexicalEditor;
-  editorState: EditorState;
-  undoSelection?: RangeSelection | NodeSelection | GridSelection | null;
-};
-export type HistoryState = {
-  current: null | HistoryStateEntry;
-  redoStack: Array<HistoryStateEntry>;
-  undoStack: Array<HistoryStateEntry>;
-};
-export function HistoryPlugin(arg0: {
-  externalHistoryState?: HistoryState;
-}): JSX.Element | null;
-export function createEmptyHistoryState(): HistoryState;
+import type { HistoryState } from '@lexical/history';
+export { createEmptyHistoryState } from '@lexical/history';
+export type { HistoryState };
+export declare function HistoryPlugin({ externalHistoryState, }: {
+    externalHistoryState?: HistoryState;
+}): null;

package/LexicalHorizontalRuleNode.d.ts

@@ -5,21 +5,23 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {LexicalNode, LexicalCommand} from 'lexical';
-import {DecoratorNode} from 'lexical';
-
-export declare class HorizontalRuleNode extends DecoratorNode<JSX.Element | null> {
-  static getType(): string;
-  static clone(node: HorizontalRuleNode): HorizontalRuleNode;
-  createDOM(): HTMLElement;
-  getTextContent(): '\n';
-  isTopLevel(): true;
-  updateDOM(): false;
-  decorate(): JSX.Element | null;
+import type { LexicalCommand, LexicalNode, SerializedLexicalNode } from 'lexical';
+import { DecoratorNode } from 'lexical';
+export declare type SerializedHorizontalRuleNode = SerializedLexicalNode & {
+    type: 'horizontalrule';
+    version: 1;
+};
+export declare const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;
+export declare class HorizontalRuleNode extends DecoratorNode<JSX.Element> {
+    static getType(): string;
+    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+    static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
+    exportJSON(): SerializedLexicalNode;
+    createDOM(): HTMLElement;
+    getTextContent(): '\n';
+    isTopLevel(): true;
+    updateDOM(): false;
+    decorate(): JSX.Element;
 }
-export function $createHorizontalRuleNode(): HorizontalRuleNode;
-export function $isHorizontalRuleNode(
-  node: LexicalNode | null | undefined,
-): node is HorizontalRuleNode;
-export var INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;
+export declare function $createHorizontalRuleNode(): HorizontalRuleNode;
+export declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;

package/LexicalLinkPlugin.d.ts

@@ -5,5 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-export function LinkPlugin(): null;
+export declare function LinkPlugin(): null;

package/LexicalLinkPlugin.dev.js

@@ -16,6 +16,7 @@ var react = require('react');
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
+ *
  */
 function LinkPlugin() {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();

package/LexicalListPlugin.d.ts

@@ -5,5 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-export function ListPlugin(): null;
+export declare function ListPlugin(): null;

package/LexicalMarkdownShortcutPlugin.d.ts

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {Transformer} from '@lexical/markdown';
-
-export function MarkdownShortcutPlugin(arg0: {
-  transformers?: Array<Transformer>;
-}): JSX.Element | null;
+import type { Transformer } from '@lexical/markdown';
+export declare function MarkdownShortcutPlugin({ transformers, }: Readonly<{
+    transformers?: Array<Transformer>;
+}>): null;

package/LexicalNestedComposer.d.ts

@@ -5,11 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {LexicalEditor, EditorThemeClasses} from 'lexical';
-
-export function LexicalNestedComposer(arg0: {
-  initialEditor: LexicalEditor;
-  initialTheme?: EditorThemeClasses;
-  children: JSX.Element | (JSX.Element | string | null)[] | null;
-}): JSX.Element | null;
+import type { EditorThemeClasses, LexicalEditor } from 'lexical';
+import { ReactNode } from 'react';
+export declare function LexicalNestedComposer({ initialEditor, children, initialTheme, }: {
+    children: ReactNode;
+    initialEditor: LexicalEditor;
+    initialTheme?: EditorThemeClasses;
+}): JSX.Element;

package/LexicalOnChangePlugin.d.ts

@@ -5,11 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import type {EditorState, LexicalEditor} from 'lexical';
-
-export function OnChangePlugin(arg0: {
-  ignoreInitialChange?: boolean;
-  ignoreSelectionChange?: boolean;
-  onChange: (editorState: EditorState, editor: LexicalEditor) => void;
+import type { EditorState, LexicalEditor } from 'lexical';
+export declare function OnChangePlugin({ ignoreInitialChange, ignoreSelectionChange, onChange, }: {
+    ignoreInitialChange?: boolean;
+    ignoreSelectionChange?: boolean;
+    onChange: (editorState: EditorState, editor: LexicalEditor) => void;
 }): null;

package/LexicalPlainTextPlugin.d.ts

@@ -5,12 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-
-import {InitialEditorStateType} from '@lexical/plain-text';
-import type {EditorState, LexicalEditor} from 'lexical';
-
-export function PlainTextPlugin(arg0: {
-  contentEditable: JSX.Element | null;
-  initialEditorState?: InitialEditorStateType;
-  placeholder: JSX.Element | string | null;
-}): JSX.Element | null;
+import { InitialEditorStateType } from '@lexical/plain-text';
+export declare function PlainTextPlugin({ contentEditable, placeholder, initialEditorState, }: {
+    contentEditable: JSX.Element;
+    initialEditorState?: InitialEditorStateType;
+    placeholder: JSX.Element | string;
+}): JSX.Element;