@byline/richtext-lexical 6.3.0 → 6.5.0

package/dist/field/extensions/link/link-target-fields.js

@@ -0,0 +1,227 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { RelationPicker } from "@byline/admin/react";
+import { getCollectionDefinition, isSingleton } from "@byline/core";
+import { Button, Checkbox, CloseIcon, EditIcon, IconButton, Input, Label, RadioGroup, RadioGroupItem, Select } from "@byline/ui/react";
+import "./link-target-fields.css";
+const LinkTargetFields = ({ idPrefix, state, onChange, linkable, allowNone, error, legend = 'Link' })=>{
+    const [pickerOpen, setPickerOpen] = useState(false);
+    const targetDefinition = state.targetCollection ? getCollectionDefinition(state.targetCollection) : null;
+    const targetDef = null == targetDefinition || isSingleton(targetDefinition) ? null : targetDefinition;
+    const collectionItems = useMemo(()=>linkable.map((c)=>({
+                label: c.labels.singular,
+                value: c.path
+            })), [
+        linkable
+    ]);
+    const pickedLabel = useMemo(()=>{
+        if ('internal' !== state.kind || !state.picked) return null;
+        const title = state.picked.document?.title;
+        if ('string' == typeof title && title.length > 0) return title;
+        const pickedDefinition = getCollectionDefinition(state.picked.targetCollectionPath);
+        const pickedDef = null == pickedDefinition || isSingleton(pickedDefinition) ? null : pickedDefinition;
+        const short = state.picked.targetDocumentId.slice(0, 8);
+        return `${pickedDef?.labels.singular ?? state.picked.targetCollectionPath} · ${short}…`;
+    }, [
+        state.kind,
+        state.picked
+    ]);
+    const handlePickerSelect = (selection)=>{
+        setPickerOpen(false);
+        const targetCollection = state.targetCollection;
+        const titleField = getCollectionDefinition(targetCollection)?.useAsTitle;
+        const title = titleField ? selection.record?.fields?.[titleField] : void 0;
+        const path = selection.record?.path;
+        const document = {};
+        if ('string' == typeof title && title.length > 0) document.title = title;
+        if ('string' == typeof path && path.length > 0) document.path = path;
+        onChange({
+            ...state,
+            picked: {
+                targetDocumentId: selection.targetDocumentId,
+                targetCollectionId: selection.targetCollectionId,
+                targetCollectionPath: targetCollection,
+                document: Object.keys(document).length > 0 ? document : void 0
+            }
+        });
+    };
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: "flex flex-col gap-3",
+                children: [
+                    /*#__PURE__*/ jsx(Label, {
+                        id: `${idPrefix}-kind-label`,
+                        htmlFor: `${idPrefix}-kind`,
+                        className: "text-sm font-medium",
+                        label: legend
+                    }),
+                    /*#__PURE__*/ jsxs(RadioGroup, {
+                        id: `${idPrefix}-kind`,
+                        name: `${idPrefix}-kind`,
+                        "aria-labelledby": `${idPrefix}-kind-label`,
+                        direction: "row",
+                        value: state.kind,
+                        onValueChange: (value)=>onChange({
+                                ...state,
+                                kind: value
+                            }),
+                        children: [
+                            allowNone && /*#__PURE__*/ jsx(RadioGroupItem, {
+                                id: `${idPrefix}-kind-none`,
+                                value: "none",
+                                label: "No link"
+                            }),
+                            linkable.length > 0 && /*#__PURE__*/ jsx(RadioGroupItem, {
+                                id: `${idPrefix}-kind-internal`,
+                                value: "internal",
+                                label: "Document"
+                            }),
+                            /*#__PURE__*/ jsx(RadioGroupItem, {
+                                id: `${idPrefix}-kind-custom`,
+                                value: "custom",
+                                label: "Custom URL"
+                            })
+                        ]
+                    }),
+                    'custom' === state.kind && /*#__PURE__*/ jsx(Input, {
+                        id: `${idPrefix}-url`,
+                        name: "url",
+                        label: "URL",
+                        placeholder: "https://example.com or /path",
+                        value: state.url,
+                        error: null != error,
+                        errorText: error ?? void 0,
+                        onChange: (e)=>onChange({
+                                ...state,
+                                url: e.target.value
+                            })
+                    }),
+                    'internal' === state.kind && /*#__PURE__*/ jsxs("div", {
+                        className: "flex flex-col gap-3",
+                        children: [
+                            linkable.length > 1 && /*#__PURE__*/ jsxs("div", {
+                                children: [
+                                    /*#__PURE__*/ jsx(Label, {
+                                        id: `${idPrefix}-collection-label`,
+                                        htmlFor: `${idPrefix}-collection`,
+                                        className: "mb-1",
+                                        label: "Target collection"
+                                    }),
+                                    /*#__PURE__*/ jsx(Select, {
+                                        size: "sm",
+                                        items: collectionItems,
+                                        placeholder: "Target collection",
+                                        value: state.targetCollection ?? void 0,
+                                        onValueChange: (value)=>{
+                                            if (null == value) return;
+                                            onChange({
+                                                ...state,
+                                                targetCollection: value
+                                            });
+                                        }
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs("div", {
+                                children: [
+                                    /*#__PURE__*/ jsx(Label, {
+                                        id: `${idPrefix}-document-label`,
+                                        htmlFor: `${idPrefix}-document`,
+                                        className: "mb-1",
+                                        label: "Target document"
+                                    }),
+                                    /*#__PURE__*/ jsx("div", {
+                                        className: "byline-link-target-frame",
+                                        children: state.picked ? /*#__PURE__*/ jsxs("div", {
+                                            className: "byline-link-target-tile",
+                                            children: [
+                                                /*#__PURE__*/ jsxs("span", {
+                                                    className: "byline-link-target-summary",
+                                                    children: [
+                                                        /*#__PURE__*/ jsx("span", {
+                                                            className: "byline-link-target-kind",
+                                                            children: targetDef?.labels.singular ?? state.picked.targetCollectionPath
+                                                        }),
+                                                        /*#__PURE__*/ jsx("span", {
+                                                            className: "byline-link-target-value",
+                                                            children: pickedLabel
+                                                        })
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ jsxs("span", {
+                                                    className: "byline-link-target-actions",
+                                                    children: [
+                                                        /*#__PURE__*/ jsx(IconButton, {
+                                                            id: `${idPrefix}-document`,
+                                                            type: "button",
+                                                            intent: "noeffect",
+                                                            size: "xs",
+                                                            "aria-label": `Change ${targetDef?.labels.singular ?? 'document'}`,
+                                                            onClick: ()=>setPickerOpen(true),
+                                                            disabled: !state.targetCollection,
+                                                            children: /*#__PURE__*/ jsx(EditIcon, {
+                                                                width: "15px",
+                                                                height: "15px"
+                                                            })
+                                                        }),
+                                                        /*#__PURE__*/ jsx(IconButton, {
+                                                            type: "button",
+                                                            intent: "noeffect",
+                                                            size: "xs",
+                                                            "aria-label": `Remove ${targetDef?.labels.singular ?? 'document'}`,
+                                                            onClick: ()=>onChange({
+                                                                    ...state,
+                                                                    picked: null
+                                                                }),
+                                                            children: /*#__PURE__*/ jsx(CloseIcon, {
+                                                                width: "15px",
+                                                                height: "15px"
+                                                            })
+                                                        })
+                                                    ]
+                                                })
+                                            ]
+                                        }) : /*#__PURE__*/ jsx(Button, {
+                                            id: `${idPrefix}-document`,
+                                            size: "xs",
+                                            variant: "outlined",
+                                            intent: "noeffect",
+                                            type: "button",
+                                            onClick: ()=>setPickerOpen(true),
+                                            disabled: !state.targetCollection,
+                                            children: `Select ${targetDef?.labels.singular ?? 'document'}`
+                                        })
+                                    })
+                                ]
+                            }),
+                            error && /*#__PURE__*/ jsx("span", {
+                                className: "text-xs text-red-400",
+                                children: error
+                            })
+                        ]
+                    }),
+                    'none' !== state.kind && /*#__PURE__*/ jsx(Checkbox, {
+                        id: `${idPrefix}-new-tab`,
+                        name: "newTab",
+                        label: "Open in new tab",
+                        checked: state.newTab,
+                        onCheckedChange: (checked)=>onChange({
+                                ...state,
+                                newTab: true === checked
+                            })
+                    })
+                ]
+            }),
+            'internal' === state.kind && state.targetCollection && /*#__PURE__*/ jsx(RelationPicker, {
+                targetCollectionPath: state.targetCollection,
+                targetDefinition: targetDef,
+                isOpen: pickerOpen,
+                onSelect: handlePickerSelect,
+                onDismiss: ()=>setPickerOpen(false)
+            })
+        ]
+    });
+};
+export { LinkTargetFields };

package/dist/field/extensions/link/link-target-state.d.ts

@@ -0,0 +1,54 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * The state machine behind "where does this link point?" — shared by the
+ * link modal and the inline-image modal so both offer the same choice of
+ * a Byline document or an arbitrary URL, with the same validation.
+ *
+ * React-free on purpose. The JSX shell lives in `link-target-fields.tsx`;
+ * everything that decides anything lives here, where it can be tested
+ * without a DOM.
+ *
+ * The one asymmetry between callers is `allowNone`. A `LinkNode` exists
+ * only because it has a target, so its form always resolves to a link. An
+ * inline image's target is optional, so its form adds a "no link" choice
+ * and `toLinkAttributes` may return `undefined` — which is precisely how
+ * an editor removes a link that is already there.
+ */
+import type { MultiCollectionDefinition } from '@byline/core';
+import type { DocumentRelation } from '../../nodes/document-relation.js';
+import type { LinkAttributes } from './index.js';
+export interface LinkTargetState {
+    /** Narrow with `LinkTargetState['kind']` rather than a separate alias. */
+    kind: 'none' | 'custom' | 'internal';
+    /** Custom-URL text. Meaningful only when `kind === 'custom'`. */
+    url: string;
+    newTab: boolean;
+    /**
+     * Which collection the picker is currently pointed at — UI state only,
+     * and deliberately independent of `picked.targetCollectionPath` so the
+     * user can browse other collections without losing their selection.
+     */
+    targetCollection: string | null;
+    /** The chosen document. Meaningful only when `kind === 'internal'`. */
+    picked: DocumentRelation | null;
+}
+export interface LinkTargetOptions {
+    /** Whether "no link at all" is a valid outcome. */
+    allowNone: boolean;
+}
+export declare function fromLinkAttributes(link: LinkAttributes | undefined, linkable: MultiCollectionDefinition[], options: LinkTargetOptions): LinkTargetState;
+/**
+ * Collapse the form back to a `LinkAttributes`, or `undefined` when there
+ * is no usable target. Callers that require a link should run
+ * `validateLinkTarget` first — this function reports "nothing to store"
+ * rather than "the user made a mistake".
+ */
+export declare function toLinkAttributes(state: LinkTargetState): LinkAttributes | undefined;
+/** Returns a human-readable problem, or `null` when the form is usable. */
+export declare function validateLinkTarget(state: LinkTargetState): string | null;

package/dist/field/extensions/link/link-target-state.js

@@ -0,0 +1,70 @@
+import { validateUrl } from "../../utils/url.js";
+function isPlaceholderUrl(url) {
+    return null == url || '' === url || 'https://' === url;
+}
+function emptyLinkTargetState(linkable, options) {
+    const firstLinkable = linkable[0]?.path ?? null;
+    const kind = options.allowNone ? 'none' : linkable.length > 0 ? 'internal' : 'custom';
+    return {
+        kind,
+        url: '',
+        newTab: false,
+        targetCollection: firstLinkable,
+        picked: null
+    };
+}
+function fromLinkAttributes(link, linkable, options) {
+    const base = emptyLinkTargetState(linkable, options);
+    if (null == link) return base;
+    if ('internal' === link.linkType) {
+        const picked = {
+            targetDocumentId: link.targetDocumentId,
+            targetCollectionId: link.targetCollectionId,
+            targetCollectionPath: link.targetCollectionPath,
+            document: link.document
+        };
+        return {
+            ...base,
+            kind: 'internal',
+            newTab: link.newTab ?? false,
+            targetCollection: picked.targetCollectionPath || base.targetCollection,
+            picked
+        };
+    }
+    const placeholder = isPlaceholderUrl(link.url);
+    const kind = placeholder && linkable.length > 0 ? 'internal' : 'custom';
+    return {
+        ...base,
+        kind,
+        url: placeholder ? '' : link.url ?? '',
+        newTab: link.newTab ?? false
+    };
+}
+function toLinkAttributes(state) {
+    if ('none' === state.kind) return;
+    if ('internal' === state.kind) {
+        if (null == state.picked) return;
+        return {
+            linkType: 'internal',
+            newTab: state.newTab,
+            targetDocumentId: state.picked.targetDocumentId,
+            targetCollectionId: state.picked.targetCollectionId,
+            targetCollectionPath: state.picked.targetCollectionPath,
+            document: state.picked.document
+        };
+    }
+    if (0 === state.url.length) return;
+    return {
+        linkType: 'custom',
+        url: state.url,
+        newTab: state.newTab
+    };
+}
+function validateLinkTarget(state) {
+    if ('none' === state.kind) return null;
+    if ('internal' === state.kind) return null == state.picked ? 'Pick a target document' : null;
+    if (0 === state.url.length) return 'Enter a URL or a root-relative path starting with /';
+    if (!state.url.startsWith('/') && !validateUrl(state.url)) return 'Enter a valid URL or a root-relative path starting with /';
+    return null;
+}
+export { fromLinkAttributes, toLinkAttributes, validateLinkTarget };

package/dist/field/extensions/link/populate.d.ts

@@ -5,5 +5,19 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-import type { LexicalNodeVisitor } from '../../lexical-populate-shared.js';
+import type { LexicalNodeVisitor, PendingHydration } from '../../lexical-populate-shared.js';
+/**
+ * Build the `apply` / `applyMissing` pair that refreshes an internal-link
+ * relation envelope in place.
+ *
+ * Shared by `linkVisitor` (where the envelope is `node.attributes`) and by
+ * the inline-image plugin's `inlineImageLinkVisitor` (where it is
+ * `node.link`). Both carry the same `DocumentRelation` shape and want the
+ * same three branches, so the resolution rules documented above live here
+ * once rather than being copied per node type.
+ *
+ * `envelope` is mutated in place — the caller owns where it hangs off the
+ * node.
+ */
+export declare function createInternalLinkHydration(envelope: Record<string, any>, collectionPath: string, documentId: string): Pick<PendingHydration, 'apply' | 'applyMissing'>;
 export declare const linkVisitor: LexicalNodeVisitor;

package/dist/field/extensions/link/populate.js

@@ -1,4 +1,57 @@
 import { getCollectionDefinition, getLogger } from "@byline/core";
+function createInternalLinkHydration(envelope, collectionPath, documentId) {
+    return {
+        apply (target) {
+            const definition = getCollectionDefinition(collectionPath);
+            const useAsTitle = definition?.useAsTitle ?? 'title';
+            const targetFields = target.fields ?? {};
+            const next = {
+                ...envelope.document ?? {}
+            };
+            const title = targetFields[useAsTitle];
+            if ('string' == typeof title && title.length > 0) next.title = title;
+            let pathThrew = false;
+            let built;
+            if (definition?.buildDocumentPath != null) try {
+                built = definition.buildDocumentPath({
+                    id: target.id,
+                    path: target.path,
+                    status: target.status,
+                    fields: targetFields
+                }, {
+                    collectionPath
+                });
+            } catch (err) {
+                pathThrew = true;
+                getLogger().info({
+                    collectionPath,
+                    documentId,
+                    err
+                }, 'buildDocumentPath threw');
+            }
+            if (!pathThrew) if ('string' == typeof built) next.path = built;
+            else {
+                const targetPath = target.path;
+                if ('string' == typeof targetPath && targetPath.length > 0) next.path = `/${collectionPath}/${targetPath}`;
+            }
+            if ('_resolved' in next) delete next._resolved;
+            envelope.document = next;
+        },
+        applyMissing () {
+            getLogger().warn({
+                collectionPath,
+                documentId
+            }, 'internal link target not found');
+            const next = {
+                ...envelope.document ?? {}
+            };
+            delete next.title;
+            delete next.path;
+            next._resolved = false;
+            envelope.document = next;
+        }
+    };
+}
 const linkVisitor = {
     match (node) {
         if ('link' !== node.type) return null;
@@ -12,56 +65,8 @@ const linkVisitor = {
             node,
             collectionPath,
             documentId,
-            apply (target) {
-                const definition = getCollectionDefinition(collectionPath);
-                const useAsTitle = definition?.useAsTitle ?? 'title';
-                const targetFields = target.fields ?? {};
-                const next = {
-                    ...attributes.document ?? {}
-                };
-                const title = targetFields[useAsTitle];
-                if ('string' == typeof title && title.length > 0) next.title = title;
-                let pathThrew = false;
-                let built;
-                if (definition?.buildDocumentPath != null) try {
-                    built = definition.buildDocumentPath({
-                        id: target.id,
-                        path: target.path,
-                        status: target.status,
-                        fields: targetFields
-                    }, {
-                        collectionPath
-                    });
-                } catch (err) {
-                    pathThrew = true;
-                    getLogger().info({
-                        collectionPath,
-                        documentId,
-                        err
-                    }, 'buildDocumentPath threw');
-                }
-                if (!pathThrew) if ('string' == typeof built) next.path = built;
-                else {
-                    const targetPath = target.path;
-                    if ('string' == typeof targetPath && targetPath.length > 0) next.path = `/${collectionPath}/${targetPath}`;
-                }
-                if ('_resolved' in next) delete next._resolved;
-                attributes.document = next;
-            },
-            applyMissing () {
-                getLogger().warn({
-                    collectionPath,
-                    documentId
-                }, 'internal link target not found');
-                const next = {
-                    ...attributes.document ?? {}
-                };
-                delete next.title;
-                delete next.path;
-                next._resolved = false;
-                attributes.document = next;
-            }
+            ...createInternalLinkHydration(attributes, collectionPath, documentId)
         };
     }
 };
-export { linkVisitor };
+export { createInternalLinkHydration, linkVisitor };

package/dist/field/markdown/lexical-to-markdown.js

@@ -253,7 +253,12 @@ function serializeImage(node, ctx) {
     const src = 'string' == typeof node.src ? node.src : '';
     if (0 === src.length) return '';
     const alt = 'string' == typeof node.altText ? node.altText : '';
-    const image = `![${alt.replace(/[[\]]/g, '')}](${src})`;
+    let image = `![${alt.replace(/[[\]]/g, '')}](${src})`;
+    const link = node.link;
+    if (null != link) {
+        const href = resolveLinkUrl(link, ctx);
+        if (null != href) image = `[${image}](${href})`;
+    }
     const caption = node.caption;
     if (true === node.showCaption && caption?.editorState != null) {
         const captionRoot = resolveRoot(caption.editorState);

package/dist/field/plugins/toolbar-plugin/index.js

@@ -1,7 +1,8 @@
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Fragment as external_react_Fragment, useCallback, useEffect, useMemo, useState } from "react";
-import { $createCodeNode, $isCodeNode, CODE_LANGUAGE_FRIENDLY_NAME_MAP, CODE_LANGUAGE_MAP, CodeNode, getLanguageFriendlyName } from "@lexical/code";
+import { $createCodeNode, $isCodeNode, CodeNode } from "@lexical/code";
+import { CODE_LANGUAGE_FRIENDLY_NAME_MAP, CODE_LANGUAGE_MAP, getLanguageFriendlyName } from "@lexical/code-prism";
 import { $isListNode, CheckListExtension, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode, REMOVE_LIST_COMMAND } from "@lexical/list";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { $isDecoratorBlockNode } from "@lexical/react/LexicalDecoratorBlockNode";

package/dist/field/utils/getSelectedNode.js

@@ -7,6 +7,6 @@ function getSelectedNode(selection) {
     if (anchorNode === focusNode) return anchorNode;
     const isBackward = selection.isBackward();
     if (isBackward) return $isAtNodeEnd(focus) ? anchorNode : focusNode;
-    return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+    else return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
 }
 export { getSelectedNode };

package/dist/field/utils/rect.js

@@ -38,8 +38,7 @@ class Rect {
                 },
                 result
             };
-        }
-        {
+        } else {
             const { top, left, bottom, right } = target;
             return top >= this._top && top <= this._bottom && bottom >= this._top && bottom <= this._bottom && left >= this._left && left <= this._right && right >= this._left && right <= this._right;
         }

package/dist/richtext-field.js

@@ -45,7 +45,7 @@ const RichTextField = ({ field, value, defaultValue, editorConfig, readonly = fa
                     id: fieldId,
                     name: field.name,
                     description: field.helpText,
-                    readonly: readonly,
+                    readonly: readonly || true === field.readOnly,
                     label: labelNode,
                     required: !field.optional,
                     value: incomingValue,

package/dist/server.d.ts

@@ -42,7 +42,7 @@ export { defaultEditorConfig } from './field/config/default.js';
 export { lexicalToText } from './field/lexical-to-text.js';
 export { type LexicalToMarkdownOptions, type LexicalToMarkdownResult, type LexicalToMarkdownWarning, lexicalToMarkdown, } from './field/markdown/lexical-to-markdown.js';
 import { type LexicalToMarkdownOptions } from './field/markdown/lexical-to-markdown.js';
-export { inlineImageVisitor } from './field/extensions/inline-image/populate.js';
+export { inlineImageLinkVisitor, inlineImageVisitor, } from './field/extensions/inline-image/populate.js';
 export { linkVisitor } from './field/extensions/link/populate.js';
 export type { EditorConfig, EditorSettings, EditorSettingsOverride } from './field/config/types.js';
 export type { LexicalNodeLike, LexicalNodeVisitor, PendingHydration, } from './field/lexical-populate-shared.js';
@@ -56,7 +56,7 @@ export interface LexicalServerOptions {
     getClient: () => BylineClient<any>;
     /**
      * Override the visitor list. Defaults to every visitor the package
-     * ships — currently `[inlineImageVisitor, linkVisitor]`. Useful when a
+     * ships — currently `[inlineImageVisitor, inlineImageLinkVisitor, linkVisitor]`. Useful when a
      * host wants to register additional custom visitors alongside the
      * built-ins, or temporarily disable a built-in:
      *

package/dist/server.js

@@ -1,4 +1,4 @@
-import { inlineImageVisitor } from "./field/extensions/inline-image/populate.js";
+import { inlineImageLinkVisitor, inlineImageVisitor } from "./field/extensions/inline-image/populate.js";
 import { linkVisitor } from "./field/extensions/link/populate.js";
 import { runLexicalPopulate } from "./field/lexical-populate-shared.js";
 import { lexicalToMarkdown } from "./field/markdown/lexical-to-markdown.js";
@@ -6,6 +6,7 @@ import { lexicalToText } from "./field/lexical-to-text.js";
 function lexicalEditorPopulateServer(options) {
     const visitors = options.visitors ?? [
         inlineImageVisitor,
+        inlineImageLinkVisitor,
         linkVisitor
     ];
     return async (ctx)=>{
@@ -28,6 +29,7 @@ function lexicalEditorToTextServer() {
 function lexicalEditorEmbedServer(options) {
     const visitors = options.visitors ?? [
         inlineImageVisitor,
+        inlineImageLinkVisitor,
         linkVisitor
     ];
     return async (ctx)=>{
@@ -42,4 +44,4 @@ function lexicalEditorEmbedServer(options) {
     };
 }
 export { defaultEditorConfig } from "./field/config/default.js";
-export { inlineImageVisitor, lexicalEditorEmbedServer, lexicalEditorPopulateServer, lexicalEditorToMarkdownServer, lexicalEditorToTextServer, lexicalToMarkdown, lexicalToText, linkVisitor };
+export { inlineImageLinkVisitor, inlineImageVisitor, lexicalEditorEmbedServer, lexicalEditorPopulateServer, lexicalEditorToMarkdownServer, lexicalEditorToTextServer, lexicalToMarkdown, lexicalToText, linkVisitor };

package/dist/validate/createEmptyEditorState.d.ts

@@ -1,4 +1,4 @@
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import type { SerializedEditorState } from 'lexical';
 /**
  * createEmptyEditorState
  * @returns
@@ -21,4 +21,4 @@ import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
         "version": 1
     }
  */
-export declare function createEmptyEditorState(): SerializedEditorState<SerializedLexicalNode>;
+export declare function createEmptyEditorState(): SerializedEditorState;

package/dist/validate/hasText.d.ts

@@ -1,2 +1,2 @@
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-export declare function hasText(value: SerializedEditorState<SerializedLexicalNode> | null | undefined): boolean;
+import type { SerializedEditorState } from 'lexical';
+export declare function hasText(value: SerializedEditorState | null | undefined): boolean;