@lexical/react 0.1.10 → 0.1.13

package/LexicalContentEditable.dev.js

@@ -9,6 +9,27 @@
 var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
 var React = require('react');
 
+/**
+ * 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.
+ *
+ * 
+ */
+const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+
+/**
+ * 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.
+ *
+ * 
+ */
+const useLayoutEffectImpl = CAN_USE_DOM ? React.useLayoutEffect : React.useEffect;
+var useLayoutEffect = useLayoutEffectImpl;
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -32,7 +53,6 @@ function LexicalContentEditable({
   autoComplete,
   autoCorrect,
   className,
-  readOnly = false,
   role = 'textbox',
   spellCheck = true,
   style,
@@ -40,28 +60,35 @@ function LexicalContentEditable({
   testid
 }) {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const [isReadOnly, setReadOnly] = React.useState(true);
   const ref = React.useCallback(rootElement => {
     editor.setRootElement(rootElement);
   }, [editor]);
+  useLayoutEffect(() => {
+    setReadOnly(editor.isReadOnly());
+    return editor.addListener('readonly', currentIsReadOnly => {
+      setReadOnly(currentIsReadOnly);
+    });
+  }, [editor]);
   return /*#__PURE__*/React.createElement("div", {
-    "aria-activedescendant": readOnly ? null : ariaActiveDescendantID,
-    "aria-autocomplete": readOnly ? null : ariaAutoComplete,
-    "aria-controls": readOnly ? null : ariaControls,
+    "aria-activedescendant": isReadOnly ? null : ariaActiveDescendantID,
+    "aria-autocomplete": isReadOnly ? null : ariaAutoComplete,
+    "aria-controls": isReadOnly ? null : ariaControls,
     "aria-describedby": ariaDescribedBy,
-    "aria-expanded": readOnly ? null : role === 'combobox' ? !!ariaExpanded : null,
+    "aria-expanded": isReadOnly ? null : role === 'combobox' ? !!ariaExpanded : null,
     "aria-label": ariaLabel,
     "aria-labelledby": ariaLabelledBy,
     "aria-multiline": ariaMultiline,
-    "aria-owns": readOnly ? null : ariaOwneeID,
+    "aria-owns": isReadOnly ? null : ariaOwneeID,
     "aria-required": ariaRequired,
     autoCapitalize: autoCapitalize,
     autoComplete: autoComplete,
     autoCorrect: autoCorrect,
     className: className,
-    contentEditable: !readOnly,
+    contentEditable: !isReadOnly,
     "data-testid": testid,
     ref: ref,
-    role: readOnly ? null : role,
+    role: isReadOnly ? null : role,
     spellCheck: spellCheck,
     style: style,
     tabIndex: tabIndex

package/LexicalContentEditable.js.flow

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+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,
+}>;
+
+declare export default function LexicalContentEditable(
+  props: Props,
+): React$Node;

package/LexicalContentEditable.prod.js

@@ -4,6 +4,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var b=require("@lexical/react/LexicalComposerContext"),e=require("react");
-module.exports=function({ariaActiveDescendantID:f,ariaAutoComplete:g,ariaControls:h,ariaDescribedBy:k,ariaExpanded:l,ariaLabel:m,ariaLabelledBy:n,ariaMultiline:p,ariaOwneeID:q,ariaRequired:r,autoCapitalize:t,autoComplete:u,autoCorrect:v,className:w,readOnly:a=!1,role:c="textbox",spellCheck:x=!0,style:y,tabIndex:z,testid:A}){const [d]=b.useLexicalComposerContext(),C=e.useCallback(B=>{d.setRootElement(B)},[d]);return e.createElement("div",{"aria-activedescendant":a?null:f,"aria-autocomplete":a?null:
-g,"aria-controls":a?null:h,"aria-describedby":k,"aria-expanded":a?null:"combobox"===c?!!l:null,"aria-label":m,"aria-labelledby":n,"aria-multiline":p,"aria-owns":a?null:q,"aria-required":r,autoCapitalize:t,autoComplete:u,autoCorrect:v,className:w,contentEditable:!a,"data-testid":A,ref:C,role:a?null:c,spellCheck:x,style:y,tabIndex:z})};
+var b=require("@lexical/react/LexicalComposerContext"),g=require("react"),h="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?g.useLayoutEffect:g.useEffect;
+module.exports=function({ariaActiveDescendantID:k,ariaAutoComplete:l,ariaControls:m,ariaDescribedBy:n,ariaExpanded:p,ariaLabel:q,ariaLabelledBy:r,ariaMultiline:t,ariaOwneeID:u,ariaRequired:v,autoCapitalize:w,autoComplete:x,autoCorrect:y,className:z,role:e="textbox",spellCheck:A=!0,style:B,tabIndex:C,testid:D}){const [c]=b.useLexicalComposerContext(),[a,f]=g.useState(!0),E=g.useCallback(d=>{c.setRootElement(d)},[c]);h(()=>{f(c.isReadOnly());return c.addListener("readonly",d=>{f(d)})},[c]);return g.createElement("div",
+{"aria-activedescendant":a?null:k,"aria-autocomplete":a?null:l,"aria-controls":a?null:m,"aria-describedby":n,"aria-expanded":a?null:"combobox"===e?!!p:null,"aria-label":q,"aria-labelledby":r,"aria-multiline":t,"aria-owns":a?null:u,"aria-required":v,autoCapitalize:w,autoComplete:x,autoCorrect:y,className:z,contentEditable:!a,"data-testid":D,ref:E,role:a?null:e,spellCheck:A,style:B,tabIndex:C})};

package/LexicalHashtagPlugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 default function LexicalHashtagPlugin(): React.ReactNode;

package/LexicalHashtagPlugin.js.flow

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+declare export default function LexicalHashtagPlugin(): React$Node;

package/LexicalHistoryPlugin.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 {
+  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;
+}): React.ReactNode;
+export function createEmptyHistoryState(): HistoryState;

package/LexicalHistoryPlugin.js.flow

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+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>,
+};
+
+declare export function HistoryPlugin({
+  externalHistoryState?: HistoryState,
+}): React$Node;
+
+declare export function createEmptyHistoryState(): HistoryState;

package/LexicalHorizontalRuleNode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 'lexical';
+import {DecoratorNode} from 'lexical';
+export declare class HorizontalRuleNode extends DecoratorNode<React.ReactNode> {
+  getType(): string;
+  clone(node: HorizontalRuleNode): HorizontalRuleNode;
+  createDOM(): HTMLElement;
+  getTextContent(): '\n';
+  isTopLevel(): true;
+  updateDOM(): false;
+  decorate(): React.ReactNode;
+}
+export function $createHorizontalRuleNode(): HorizontalRuleNode;
+export function $isHorizontalRuleNode(
+  node: LexicalNode | null | undefined,
+): boolean;

package/LexicalHorizontalRuleNode.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+import type {LexicalNode} from 'lexical';
+
+import {DecoratorNode} from 'lexical';
+
+declare export class HorizontalRuleNode extends DecoratorNode<React$Node> {
+  static getType(): string;
+  static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+  createDOM(): HTMLElement;
+  getTextContent(): '\n';
+  isTopLevel(): true;
+  updateDOM(): false;
+  decorate(): React$Node;
+}
+
+declare export function $createHorizontalRuleNode(): HorizontalRuleNode;
+declare export function $isHorizontalRuleNode(node: ?LexicalNode): boolean;

package/LexicalLinkPlugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 default function LexicalLinkPlugin(): null;

package/LexicalLinkPlugin.js.flow

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+declare export default function LexicalLinkPlugin(): null;

package/LexicalListPlugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 default function ListPlugin(): null;

package/LexicalListPlugin.dev.js

@@ -43,6 +43,12 @@ function useList(editor) {
       } else if (type === 'removeList') {
         list.removeList(editor);
         return true;
+      } else if (type === 'insertParagraph') {
+        const hasHandledInsertParagraph = list.$handleListInsertParagraph();
+
+        if (hasHandledInsertParagraph) {
+          return true;
+        }
       }
 
       return false;

package/LexicalListPlugin.js.flow

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+declare export default function ListPlugin(): null;

package/LexicalListPlugin.prod.js

@@ -4,5 +4,5 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var b=require("@lexical/react/LexicalComposerContext"),d=require("@lexical/list"),e=require("react");function f(a){e.useEffect(()=>a.addListener("command",c=>{if("indentContent"===c){if(d.indentList())return!0}else if("outdentContent"===c){if(d.outdentList())return!0}else{if("insertOrderedList"===c)return d.insertList(a,"ol"),!0;if("insertUnorderedList"===c)return d.insertList(a,"ul"),!0;if("removeList"===c)return d.removeList(a),!0}return!1},1),[a])}
-module.exports=function(){const [a]=b.useLexicalComposerContext();f(a);return null};
+var b=require("@lexical/react/LexicalComposerContext"),d=require("@lexical/list"),e=require("react");
+function f(a){e.useEffect(()=>a.addListener("command",c=>{if("indentContent"===c){if(d.indentList())return!0}else if("outdentContent"===c){if(d.outdentList())return!0}else{if("insertOrderedList"===c)return d.insertList(a,"ol"),!0;if("insertUnorderedList"===c)return d.insertList(a,"ul"),!0;if("removeList"===c)return d.removeList(a),!0;if("insertParagraph"===c&&d.$handleListInsertParagraph())return!0}return!1},1),[a])}module.exports=function(){const [a]=b.useLexicalComposerContext();f(a);return null};

package/LexicalNestedComposer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 {DecoratorEditor, EditorThemeClasses} from 'lexical';
+
+export default function LexicalNestedComposer(arg0: {
+  initialConfig: {
+    decoratorEditor: DecoratorEditor;
+    theme?: EditorThemeClasses;
+  };
+  children: React.ReactNode;
+}): React.ReactNode;

package/LexicalNestedComposer.dev.js

@@ -7,6 +7,7 @@
 'use strict';
 
 var LexicalComposer = require('@lexical/react/LexicalComposer');
+var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
 var LexicalOnChangePlugin = require('@lexical/react/LexicalOnChangePlugin');
 var React = require('react');
 
@@ -22,13 +23,18 @@ function LexicalNestedComposer({
   initialConfig = {},
   children
 }) {
+  const parentContext = React.useContext(LexicalComposerContext.LexicalComposerContext);
+
+  if (parentContext == null) {
+    {
+      throw Error(`Unexpected parent context null on a nested composer`);
+    }
+  }
+
   const [nestedEditor, setNestedEditor] = React.useState(null);
   const {
     decoratorEditor,
-    namespace,
-    theme,
-    nodes,
-    onError
+    theme
   } = initialConfig;
   React.useEffect(() => {
     if (!decoratorEditor.isEmpty() && nestedEditor !== null) {
@@ -45,13 +51,17 @@ function LexicalNestedComposer({
   }, // eslint-disable-next-line react-hooks/exhaustive-deps
   []);
   return /*#__PURE__*/React.createElement(LexicalComposer, {
-    initialConfig: {
-      editor: decoratorEditor.editor,
-      namespace,
-      nodes,
-      onError,
-      theme
-    }
+    initialConfig: React.useMemo(() => {
+      const [parentEditor] = parentContext;
+      return {
+        editor: decoratorEditor.editor,
+        namespace: parentEditor._config.namespace,
+        nodes: Array.from(parentEditor._nodes.values()).map(registeredNode => registeredNode.klass),
+        onError: parentEditor._onError,
+        theme
+      }; // We only do this for init
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [])
   }, /*#__PURE__*/React.createElement(LexicalOnChangePlugin, {
     onChange: onChange
   }), children);

package/LexicalNestedComposer.js.flow

@@ -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.
+ *
+ * @flow strict
+ */
+
+import type {DecoratorEditor, EditorThemeClasses, LexicalNode} from 'lexical';
+
+declare export default function LexicalNestedComposer({
+  initialConfig: $ReadOnly<{
+    decoratorEditor: DecoratorEditor,
+    theme?: EditorThemeClasses,
+  }>,
+  children: React$Node,
+}): React$Node;

package/LexicalNestedComposer.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.
  */
-var a=require("@lexical/react/LexicalComposer"),f=require("@lexical/react/LexicalOnChangePlugin"),g=require("react");
-module.exports=function({initialConfig:c={},children:h}){const [d,k]=g.useState(null),{decoratorEditor:b,namespace:l,theme:m,nodes:n,onError:p}=c;g.useEffect(()=>{b.isEmpty()||null===d||b.init(d)},[d]);c=g.useCallback((q,e)=>{q.isEmpty()?k(e):b.set(e)},[]);return g.createElement(a,{initialConfig:{editor:b.editor,namespace:l,nodes:n,onError:p,theme:m}},g.createElement(f,{onChange:c}),h)};
+var a=require("@lexical/react/LexicalComposer"),h=require("@lexical/react/LexicalComposerContext"),k=require("@lexical/react/LexicalOnChangePlugin"),l=require("react");
+module.exports=function({initialConfig:e={},children:m}){const g=l.useContext(h.LexicalComposerContext);if(null==g)throw Error("Unexpected parent context null on a nested composer");const [f,n]=l.useState(null),{decoratorEditor:c,theme:p}=e;l.useEffect(()=>{c.isEmpty()||null===f||c.init(f)},[f]);e=l.useCallback((b,d)=>{b.isEmpty()?n(d):c.set(d)},[]);return l.createElement(a,{initialConfig:l.useMemo(()=>{const [b]=g;return{editor:c.editor,namespace:b._config.namespace,nodes:Array.from(b._nodes.values()).map(d=>
+d.klass),onError:b._onError,theme:p}},[])},l.createElement(k,{onChange:e}),m)};

package/LexicalOnChangePlugin.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 {EditorState, LexicalEditor} from 'lexical';
+export default function OnChangePlugin(arg0: {
+  onChange: (editorState: EditorState, editor: LexicalEditor) => void;
+}): null;

package/LexicalOnChangePlugin.js.flow

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+import type {EditorState, LexicalEditor} from 'lexical';
+
+declare export default function OnChangePlugin({
+  onChange: (editorState: EditorState, editor: LexicalEditor) => void,
+}): null;

package/LexicalPlainTextPlugin.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 {EditorState} from 'lexical';
+type InitialEditorStateType = null | string | EditorState | (() => void);
+export default function PlainTextPlugin(arg0: {
+  contentEditable: React.ReactNode;
+  initialEditorState?: InitialEditorStateType;
+  placeholder: React.ReactNode;
+}): React.ReactNode;