docs(richtext-lexical): various documentation improvements

docs/rich-text/lexical.mdx

@@ -321,6 +321,24 @@ const headlessEditor = await createHeadlessEditor({
 })
 ```
 
+### Getting the editor config
+
+As you can see, you need to provide an editor config in order to create a headless editor. This is because the editor config is used to determine which nodes & features are enabled, and which converters are used.
+
+To get the editor config, simply import the default editor config and adjust it - just like you did inside of the `editor: lexicalEditor({})` property:
+
+```ts
+import { defaultEditorConfig, defaultEditorFeatures } from '@payloadcms/richtext-lexical' // <= make sure this package is installed
+
+const yourEditorConfig = defaultEditorConfig
+
+// If you made changes to the features of the field's editor config, you should also make those changes here:
+yourEditorConfig.features = [
+  ...defaultEditorFeatures,
+  // Add your custom features here
+]
+```
+
 ### HTML => Lexical
 
 Once you have your headless editor instance, you can use it to convert HTML to Lexical:
@@ -328,13 +346,14 @@ Once you have your headless editor instance, you can use it to convert HTML to L
 ```ts
 import { $generateNodesFromDOM } from '@lexical/html'
 import { $getRoot,$getSelection } from 'lexical'
+import JSDOM from 'jsdom'
 
 headlessEditor.update(() => {
   // In a headless environment you can use a package such as JSDom to parse the HTML string.
   const dom = new JSDOM(htmlString)
 
   // Once you have the DOM instance it's easy to generate LexicalNodes.
-  const nodes = $generateNodesFromDOM(editor, dom.window.document)
+  const nodes = $generateNodesFromDOM(headlessEditor, dom.window.document)
 
   // Select the root
   $getRoot().select()
@@ -348,6 +367,8 @@ headlessEditor.update(() => {
 const editorJSON = headlessEditor.getEditorState().toJSON()
 ```
 
+Functions prefixed with a `$` can only be run inside of an `editor.update()` or `editorState.read()` callback.
+
 This has been taken from the [lexical serialization & deserialization docs](https://lexical.dev/docs/concepts/serialization#html---lexical).
 
 <Banner type="success">
@@ -395,7 +416,6 @@ try {
   headlessEditor.setEditorState(headlessEditor.parseEditorState(yourEditorState)) // This should commit the editor state immediately
 } catch (e) {
   logger.error({ err: e }, 'ERROR parsing editor state')
-  return ''
 }
 
 // Export to markdown
@@ -407,6 +427,35 @@ headlessEditor.getEditorState().read(() => {
 
 The `.setEditorState()` function immediately updates your editor state. Thus, there's no need for the `discrete: true` flag when reading the state afterward.
 
+
+### Lexical => Plain Text
+
+Export content from the Lexical editor into plain text using these steps:
+
+1. Import your current editor state into the headless editor.
+2. Convert and fetch the resulting plain text string.
+
+Here's the code for it:
+
+```ts
+import type { SerializedEditorState } from "lexical"
+import { $getRoot } from "lexical"
+
+const yourEditorState: SerializedEditorState // <= your current editor state here
+
+// Import editor state into your headless editor
+try {
+  headlessEditor.setEditorState(headlessEditor.parseEditorState(yourEditorState)) // This should commit the editor state immediately
+} catch (e) {
+  logger.error({ err: e }, 'ERROR parsing editor state')
+}
+
+// Export to plain text
+const plainTextContent = headlessEditor.getEditorState().read(() => {
+  return $getRoot().getTextContent()
+}) || ''
+```
+
 ## Migrating from Slate
 
 While both Slate and Lexical save the editor state in JSON, the structure of the JSON is different.