@moldable-ai/editor 0.1.1

package/dist/lib/lexical/floating-toolbar-plugin.js

@@ -0,0 +1,237 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useCallback, useEffect, useState } from 'react';
+import { $splitNodesAtSelectionBoundaries } from './split-node-at-selection';
+import { $createCodeNode } from '@lexical/code';
+import { $isListNode, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListNode, } from '@lexical/list';
+import { $createHeadingNode, $createQuoteNode, $isHeadingNode, } from '@lexical/rich-text';
+import { $setBlocksType } from '@lexical/selection';
+import { $getNearestNodeOfType, mergeRegister } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_LOW, FORMAT_TEXT_COMMAND, SELECTION_CHANGE_COMMAND, $createParagraphNode as createParagraphNode, } from 'lexical';
+export function useFloatingToolbar() {
+    const [editor] = useLexicalComposerContext();
+    const [isVisible, setIsVisible] = useState(false);
+    const [isBold, setIsBold] = useState(false);
+    const [isItalic, setIsItalic] = useState(false);
+    const [isUnderline, setIsUnderline] = useState(false);
+    const [isStrikethrough, setIsStrikethrough] = useState(false);
+    const [isCode, setIsCode] = useState(false);
+    const [blockType, setBlockType] = useState('paragraph');
+    const [position, setPosition] = useState(null);
+    const updateToolbar = useCallback(() => {
+        const selection = $getSelection();
+        // Hide toolbar if editor is not editable (read-only mode)
+        if (!editor.isEditable()) {
+            setIsVisible(false);
+            setPosition(null);
+            return;
+        }
+        if ($isRangeSelection(selection)) {
+            const anchorNode = selection.anchor.getNode();
+            const element = anchorNode.getKey() === 'root'
+                ? anchorNode
+                : anchorNode.getTopLevelElementOrThrow();
+            const elementKey = element.getKey();
+            const elementDOM = editor.getElementByKey(elementKey);
+            // Check if selection is empty (no text selected)
+            const isCollapsed = selection.isCollapsed();
+            if (elementDOM !== null && !isCollapsed) {
+                setIsVisible(true);
+                // Update text format states
+                setIsBold(selection.hasFormat('bold'));
+                setIsItalic(selection.hasFormat('italic'));
+                setIsUnderline(selection.hasFormat('underline'));
+                setIsStrikethrough(selection.hasFormat('strikethrough'));
+                setIsCode(selection.hasFormat('code'));
+                // Update block type
+                if ($isHeadingNode(element)) {
+                    const tag = element.getTag();
+                    setBlockType(tag);
+                }
+                else if ($isListNode(element)) {
+                    const parentList = $getNearestNodeOfType(anchorNode, ListNode);
+                    const type = parentList
+                        ? parentList.getListType()
+                        : element.getListType();
+                    if (type === 'number') {
+                        setBlockType('number');
+                    }
+                    else if (type === 'check') {
+                        setBlockType('check');
+                    }
+                    else {
+                        setBlockType('bullet');
+                    }
+                }
+                else {
+                    const type = element.getType();
+                    if (type === 'quote') {
+                        setBlockType('quote');
+                    }
+                    else if (type === 'code') {
+                        setBlockType('code');
+                    }
+                    else {
+                        setBlockType('paragraph');
+                    }
+                }
+                // Calculate position from native selection
+                const nativeSelection = window.getSelection();
+                const rootElement = editor.getRootElement();
+                if (nativeSelection !== null &&
+                    nativeSelection.rangeCount > 0 &&
+                    rootElement !== null) {
+                    const range = nativeSelection.getRangeAt(0);
+                    const rect = range.getBoundingClientRect();
+                    if (rect.width > 0 || rect.height > 0) {
+                        // Use fixed positioning relative to viewport
+                        // Position at start (left) and bottom of selection
+                        setPosition({
+                            top: rect.bottom,
+                            left: rect.left,
+                        });
+                    }
+                }
+            }
+            else {
+                setIsVisible(false);
+                setPosition(null);
+            }
+        }
+        else {
+            setIsVisible(false);
+            setPosition(null);
+        }
+    }, [editor]);
+    useEffect(() => {
+        return mergeRegister(editor.registerUpdateListener(({ editorState }) => {
+            editorState.read(() => {
+                updateToolbar();
+            });
+        }), editor.registerCommand(SELECTION_CHANGE_COMMAND, () => {
+            updateToolbar();
+            return false;
+        }, COMMAND_PRIORITY_LOW));
+    }, [editor, updateToolbar]);
+    const formatBold = () => {
+        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'bold');
+    };
+    const formatItalic = () => {
+        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'italic');
+    };
+    const formatUnderline = () => {
+        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'underline');
+    };
+    const formatStrikethrough = () => {
+        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'strikethrough');
+    };
+    const formatCode = () => {
+        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'code');
+    };
+    const formatParagraph = () => {
+        editor.update(() => {
+            const selection = $getSelection();
+            if ($isRangeSelection(selection)) {
+                $setBlocksType(selection, () => createParagraphNode());
+            }
+        });
+    };
+    const formatHeading = (headingSize) => {
+        if (blockType !== headingSize) {
+            editor.update(() => {
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    // Split nodes at selection boundaries to ensure we only convert
+                    // the selected portion, not entire blocks
+                    $splitNodesAtSelectionBoundaries(selection);
+                    // Get the updated selection after splitting
+                    const updatedSelection = $getSelection();
+                    if ($isRangeSelection(updatedSelection)) {
+                        // Now apply the heading style - this will only affect blocks
+                        // that are within or intersect with the selection
+                        $setBlocksType(updatedSelection, () => $createHeadingNode(headingSize));
+                    }
+                }
+            });
+        }
+    };
+    const formatBulletList = () => {
+        editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
+    };
+    const formatNumberedList = () => {
+        editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined);
+    };
+    const formatCheckList = () => {
+        editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
+    };
+    const formatQuote = () => {
+        if (blockType !== 'quote') {
+            editor.update(() => {
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    $setBlocksType(selection, () => $createQuoteNode());
+                }
+            });
+        }
+    };
+    const formatCodeBlock = () => {
+        if (blockType !== 'code') {
+            editor.update(() => {
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    $setBlocksType(selection, () => $createCodeNode());
+                }
+            });
+        }
+    };
+    const clearFormatting = () => {
+        editor.update(() => {
+            const selection = $getSelection();
+            if ($isRangeSelection(selection)) {
+                // Convert to paragraph if it's a heading, quote, or code block
+                const shouldConvertToParagraph = blockType !== 'paragraph' &&
+                    blockType !== 'bullet' &&
+                    blockType !== 'number';
+                if (shouldConvertToParagraph) {
+                    $setBlocksType(selection, () => createParagraphNode());
+                }
+            }
+        });
+        // Dispatch format commands outside the update block
+        // Toggle off any active formats
+        if (isBold)
+            editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'bold');
+        if (isItalic)
+            editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'italic');
+        if (isUnderline)
+            editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'underline');
+        if (isStrikethrough)
+            editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'strikethrough');
+        if (isCode)
+            editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'code');
+    };
+    return {
+        isVisible,
+        isBold,
+        isItalic,
+        isUnderline,
+        isStrikethrough,
+        isCode,
+        blockType,
+        editor,
+        position,
+        onBold: formatBold,
+        onItalic: formatItalic,
+        onUnderline: formatUnderline,
+        onStrikethrough: formatStrikethrough,
+        onCode: formatCode,
+        onParagraph: formatParagraph,
+        onHeading: formatHeading,
+        onBulletList: formatBulletList,
+        onNumberedList: formatNumberedList,
+        onCheckList: formatCheckList,
+        onQuote: formatQuote,
+        onCodeBlock: formatCodeBlock,
+        onClearFormatting: clearFormatting,
+    };
+}

package/dist/lib/lexical/headless-editor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a headless Lexical editor for server-side operations.
+ * Use this for translation, content extraction, etc.
+ */
+export declare function createMoldableHeadlessEditor(): import("lexical").LexicalEditor;
+//# sourceMappingURL=headless-editor.d.ts.map

package/dist/lib/lexical/headless-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless-editor.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/headless-editor.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAgB,4BAA4B,oCAkB3C"}

package/dist/lib/lexical/headless-editor.js

@@ -0,0 +1,30 @@
+import { editorTheme } from './editor-theme';
+import { CodeHighlightNode, CodeNode } from '@lexical/code';
+import { HorizontalRuleNode } from '@lexical/extension';
+import { createHeadlessEditor } from '@lexical/headless';
+import { AutoLinkNode, LinkNode } from '@lexical/link';
+import { ListItemNode, ListNode } from '@lexical/list';
+import { HeadingNode, QuoteNode } from '@lexical/rich-text';
+/**
+ * Creates a headless Lexical editor for server-side operations.
+ * Use this for translation, content extraction, etc.
+ */
+export function createMoldableHeadlessEditor() {
+    return createHeadlessEditor({
+        nodes: [
+            HeadingNode,
+            QuoteNode,
+            ListNode,
+            ListItemNode,
+            CodeNode,
+            CodeHighlightNode,
+            AutoLinkNode,
+            LinkNode,
+            HorizontalRuleNode,
+        ],
+        theme: editorTheme,
+        onError: (error) => {
+            throw error;
+        },
+    });
+}

package/dist/lib/lexical/markdown-transformers.d.ts

@@ -0,0 +1,40 @@
+import type { ElementTransformer, Transformer } from '@lexical/markdown';
+import type { ElementNode } from 'lexical';
+/**
+ * Horizontal rule transformer - supports ---, ***, and ___
+ */
+export declare const HR: ElementTransformer;
+/**
+ * All markdown transformers
+ */
+export declare const markdownTransformers: Array<Transformer>;
+/**
+ * Options for converting from markdown string
+ */
+interface ConvertFromMarkdownOptions {
+    markdown: string;
+    transformers?: Array<Transformer>;
+    node?: ElementNode;
+    shouldPreserveNewLines?: boolean;
+    shouldMergeAdjacentLines?: boolean;
+}
+/**
+ * Options for converting to markdown string
+ */
+interface ConvertToMarkdownOptions {
+    transformers?: Array<Transformer>;
+    node?: ElementNode;
+    shouldPreserveNewLines?: boolean;
+}
+/**
+ * Renders markdown from a string. The selection is moved to the start after the operation.
+ * Uses named arguments for better readability and maintainability.
+ */
+export declare function $convertFromMarkdownString({ markdown, transformers, node, shouldPreserveNewLines, shouldMergeAdjacentLines, }: ConvertFromMarkdownOptions): void;
+/**
+ * Renders string from markdown. The selection is moved to the start after the operation.
+ * Uses named arguments for better readability and maintainability.
+ */
+export declare function $convertToMarkdownString({ transformers, node, shouldPreserveNewLines, }?: ConvertToMarkdownOptions): string;
+export {};
+//# sourceMappingURL=markdown-transformers.d.ts.map

package/dist/lib/lexical/markdown-transformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-transformers.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/markdown-transformers.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACxE,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,SAAS,CAAA;AAEvD;;GAEG;AACH,eAAO,MAAM,EAAE,EAAE,kBAgBhB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,WAAW,CAOnD,CAAA;AAED;;GAEG;AACH,UAAU,0BAA0B;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;IACjC,IAAI,CAAC,EAAE,WAAW,CAAA;IAClB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,wBAAwB,CAAC,EAAE,OAAO,CAAA;CACnC;AAED;;GAEG;AACH,UAAU,wBAAwB;IAChC,YAAY,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;IACjC,IAAI,CAAC,EAAE,WAAW,CAAA;IAClB,sBAAsB,CAAC,EAAE,OAAO,CAAA;CACjC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,QAAQ,EACR,YAAmC,EACnC,IAAI,EACJ,sBAA6B,EAC7B,wBAAgC,GACjC,EAAE,0BAA0B,GAAG,IAAI,CAQnC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,YAAmC,EACnC,IAAI,EACJ,sBAA6B,GAC9B,GAAE,wBAA6B,GAAG,MAAM,CAExC"}

package/dist/lib/lexical/markdown-transformers.js

@@ -0,0 +1,52 @@
+/**
+ * Markdown Transformers for Lexical Editor
+ * Provides import/export functionality with proper newline preservation
+ */
+import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode, } from '@lexical/extension';
+import { CHECK_LIST, ELEMENT_TRANSFORMERS, MULTILINE_ELEMENT_TRANSFORMERS, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, $convertFromMarkdownString as lexicalConvertFromMarkdown, $convertToMarkdownString as lexicalConvertToMarkdown, } from '@lexical/markdown';
+/**
+ * Horizontal rule transformer - supports ---, ***, and ___
+ */
+export const HR = {
+    dependencies: [HorizontalRuleNode],
+    export: (node) => {
+        return $isHorizontalRuleNode(node) ? '***' : null;
+    },
+    regExp: /^(---|\*\*\*|___)\s?$/,
+    replace: (parentNode, _1, _2, isImport) => {
+        const line = $createHorizontalRuleNode();
+        if (isImport || parentNode.getNextSibling() != null) {
+            parentNode.replace(line);
+        }
+        else {
+            parentNode.insertBefore(line);
+        }
+        line.selectNext();
+    },
+    type: 'element',
+};
+/**
+ * All markdown transformers
+ */
+export const markdownTransformers = [
+    HR,
+    CHECK_LIST,
+    ...ELEMENT_TRANSFORMERS,
+    ...MULTILINE_ELEMENT_TRANSFORMERS,
+    ...TEXT_FORMAT_TRANSFORMERS,
+    ...TEXT_MATCH_TRANSFORMERS,
+];
+/**
+ * Renders markdown from a string. The selection is moved to the start after the operation.
+ * Uses named arguments for better readability and maintainability.
+ */
+export function $convertFromMarkdownString({ markdown, transformers = markdownTransformers, node, shouldPreserveNewLines = true, shouldMergeAdjacentLines = false, }) {
+    return lexicalConvertFromMarkdown(markdown, transformers, node, shouldPreserveNewLines, shouldMergeAdjacentLines);
+}
+/**
+ * Renders string from markdown. The selection is moved to the start after the operation.
+ * Uses named arguments for better readability and maintainability.
+ */
+export function $convertToMarkdownString({ transformers = markdownTransformers, node, shouldPreserveNewLines = true, } = {}) {
+    return lexicalConvertToMarkdown(transformers, node, shouldPreserveNewLines);
+}

package/dist/lib/lexical/split-node-at-selection.d.ts

@@ -0,0 +1,9 @@
+import { RangeSelection } from 'lexical';
+/**
+ * Splits nodes at the selection boundaries to ensure block-level formatting
+ * (like headings) only affects the selected portion, not entire blocks.
+ *
+ * @param selection The range selection to split nodes for
+ */
+export declare function $splitNodesAtSelectionBoundaries(selection: RangeSelection): void;
+//# sourceMappingURL=split-node-at-selection.d.ts.map

package/dist/lib/lexical/split-node-at-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-node-at-selection.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/split-node-at-selection.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,cAAc,EACf,MAAM,SAAS,CAAA;AAEhB;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAC9C,SAAS,EAAE,cAAc,GACxB,IAAI,CAmKN"}

package/dist/lib/lexical/split-node-at-selection.js

@@ -0,0 +1,224 @@
+import { $createParagraphNode, $isParagraphNode, $isTextNode, } from 'lexical';
+/**
+ * Splits nodes at the selection boundaries to ensure block-level formatting
+ * (like headings) only affects the selected portion, not entire blocks.
+ *
+ * @param selection The range selection to split nodes for
+ */
+export function $splitNodesAtSelectionBoundaries(selection) {
+    const anchorNode = selection.anchor.getNode();
+    const focusNode = selection.focus.getNode();
+    // Get the top-level element nodes
+    const anchorElement = anchorNode.getKey() === 'root'
+        ? anchorNode
+        : anchorNode.getTopLevelElementOrThrow();
+    const focusElement = focusNode.getKey() === 'root'
+        ? focusNode
+        : focusNode.getTopLevelElementOrThrow();
+    const anchorOffset = selection.anchor.offset;
+    const focusOffset = selection.focus.offset;
+    // Split paragraph at anchor (start of selection) if needed
+    // We need to split if there's content before the selection start
+    if ($isParagraphNode(anchorElement) && $isTextNode(anchorNode)) {
+        const shouldSplitAtAnchor = anchorOffset > 0 ||
+            (anchorOffset === 0 && anchorElement.getFirstChild() !== anchorNode);
+        if (shouldSplitAtAnchor) {
+            // If anchor and focus are in the same text node, we need to handle the focus offset
+            // after splitting because splitText will modify the original node
+            const anchorAndFocusInSameNode = anchorNode === focusNode && $isTextNode(anchorNode);
+            const originalFocusOffset = focusOffset;
+            const splitNode = $splitParagraphAtTextOffset(anchorElement, anchorNode, anchorOffset);
+            // After splitting at anchor, the focus node might have moved to a new paragraph
+            // Re-evaluate the focus element and node
+            let updatedFocusNode = selection.focus.getNode();
+            let updatedFocusOffset = selection.focus.offset;
+            // If anchor and focus were in the same node, we need to adjust the focus
+            // because splitText creates a new node for text after the split point
+            if (anchorAndFocusInSameNode &&
+                anchorOffset < originalFocusOffset &&
+                splitNode &&
+                $isTextNode(splitNode)) {
+                // The focus is now in the split node (the new node created by splitText)
+                // Calculate the adjusted offset
+                const adjustedOffset = originalFocusOffset - anchorOffset;
+                const splitNodeText = splitNode.getTextContent();
+                if (adjustedOffset >= 0 && adjustedOffset <= splitNodeText.length) {
+                    updatedFocusNode = splitNode;
+                    updatedFocusOffset = adjustedOffset;
+                    // Update the selection to point to the correct node
+                    selection.focus.set(updatedFocusNode.getKey(), updatedFocusOffset, 'text');
+                }
+            }
+            const updatedFocusElement = updatedFocusNode.getKey() === 'root'
+                ? updatedFocusNode
+                : updatedFocusNode.getTopLevelElementOrThrow();
+            // Now split at focus using the updated references
+            if ($isParagraphNode(updatedFocusElement) &&
+                $isTextNode(updatedFocusNode)) {
+                const focusTextNodeSize = updatedFocusNode.getTextContentSize();
+                const paragraphChildren = updatedFocusElement.getChildren();
+                const focusNodeIndex = paragraphChildren.indexOf(updatedFocusNode);
+                const isFocusAtEndOfTextNode = updatedFocusOffset === focusTextNodeSize;
+                const hasNodesAfterFocus = focusNodeIndex < paragraphChildren.length - 1;
+                const shouldSplitAtFocus = updatedFocusOffset < focusTextNodeSize ||
+                    (isFocusAtEndOfTextNode && hasNodesAfterFocus);
+                if (shouldSplitAtFocus) {
+                    // Split at focus - this will move content after focus to a new paragraph
+                    // The selected text (from 0 to updatedFocusOffset) remains in updatedFocusNode
+                    $splitParagraphAtTextOffset(updatedFocusElement, updatedFocusNode, updatedFocusOffset);
+                    // After splitting at focus, updatedFocusNode contains text from 0 to updatedFocusOffset
+                    // This is the selected text - update the selection to point to it
+                    if (anchorAndFocusInSameNode && $isTextNode(updatedFocusNode)) {
+                        selection.anchor.set(updatedFocusNode.getKey(), 0, 'text');
+                        selection.focus.set(updatedFocusNode.getKey(), updatedFocusOffset, 'text');
+                    }
+                }
+                else if (anchorAndFocusInSameNode && $isTextNode(updatedFocusNode)) {
+                    // No split at focus needed - selection already points to the right node
+                    // Just ensure anchor is at the start
+                    selection.anchor.set(updatedFocusNode.getKey(), 0, 'text');
+                    selection.focus.set(updatedFocusNode.getKey(), updatedFocusOffset, 'text');
+                }
+            }
+            return;
+        }
+    }
+    // If anchor and focus are in different elements, split both
+    if (anchorElement !== focusElement) {
+        if ($isParagraphNode(focusElement)) {
+            // Check if we need to split at focus
+            // We need to split if:
+            // 1. The focus offset is not at the end of the text node, OR
+            // 2. The focus node is not the last child of the paragraph (there's content after it)
+            const focusTextNodeSize = $isTextNode(focusNode)
+                ? focusNode.getTextContentSize()
+                : 0;
+            const isFocusAtEndOfTextNode = focusOffset === focusTextNodeSize;
+            const isFocusLastChild = focusElement.getLastChild() === focusNode;
+            const shouldSplitAtFocus = focusOffset < focusTextNodeSize ||
+                (isFocusAtEndOfTextNode && !isFocusLastChild);
+            if (shouldSplitAtFocus &&
+                focusOffset <= focusElement.getTextContentSize()) {
+                $splitParagraphAtTextOffset(focusElement, focusNode, focusOffset);
+            }
+        }
+    }
+    else {
+        // Same element and we didn't split at anchor - we need to split at focus
+        if ($isParagraphNode(focusElement) && $isTextNode(focusNode)) {
+            // Check if we need to split at focus
+            // We split if there's content after the focus point
+            const focusTextNodeSize = focusNode.getTextContentSize();
+            const paragraphChildren = focusElement.getChildren();
+            const focusNodeIndex = paragraphChildren.indexOf(focusNode);
+            const isFocusAtEndOfTextNode = focusOffset === focusTextNodeSize;
+            const hasNodesAfterFocus = focusNodeIndex < paragraphChildren.length - 1;
+            const shouldSplitAtFocus = focusOffset < focusTextNodeSize ||
+                (isFocusAtEndOfTextNode && hasNodesAfterFocus);
+            if (shouldSplitAtFocus) {
+                $splitParagraphAtTextOffset(focusElement, focusNode, focusOffset);
+            }
+        }
+    }
+}
+/**
+ * Splits a paragraph node at a specific text offset.
+ * Creates a new paragraph node and moves the content after the offset to it.
+ *
+ * @param paragraph The paragraph element to split
+ * @param textNode The text node containing the offset
+ * @param offset The text offset at which to split
+ * @returns The first text node in the new paragraph (the split node), or null if no split occurred
+ */
+function $splitParagraphAtTextOffset(paragraph, textNode, offset) {
+    if (!$isParagraphNode(paragraph)) {
+        return null;
+    }
+    if (!$isTextNode(textNode)) {
+        return null;
+    }
+    const children = paragraph.getChildren();
+    const textNodeIndex = children.indexOf(textNode);
+    if (textNodeIndex === -1) {
+        return null;
+    }
+    const textNodeSize = textNode.getTextContentSize();
+    // If offset is 0 and text node is not the first child, split before the text node
+    if (offset === 0 && textNodeIndex > 0) {
+        const newParagraph = $createParagraphNode();
+        // Move this text node and all subsequent nodes to the new paragraph
+        for (let i = textNodeIndex; i < children.length; i++) {
+            const node = children[i];
+            if (node) {
+                node.remove();
+                newParagraph.append(node);
+            }
+        }
+        paragraph.insertAfter(newParagraph);
+        // Return the first text node in the new paragraph
+        const newParagraphChildren = newParagraph.getChildren();
+        return newParagraphChildren.find((node) => $isTextNode(node)) || null;
+    }
+    // If offset is at the end of the text node, we need to split after the text node
+    if (offset === textNodeSize) {
+        // Check if there are nodes after this text node
+        if (textNodeIndex < children.length - 1) {
+            const newParagraph = $createParagraphNode();
+            // Move all nodes after the text node to the new paragraph
+            for (let i = textNodeIndex + 1; i < children.length; i++) {
+                const node = children[i];
+                if (node) {
+                    node.remove();
+                    newParagraph.append(node);
+                }
+            }
+            paragraph.insertAfter(newParagraph);
+            // Return the first text node in the new paragraph
+            const newParagraphChildren = newParagraph.getChildren();
+            return newParagraphChildren.find((node) => $isTextNode(node)) || null;
+        }
+        return null;
+    }
+    // Split the text node if offset is within the text node
+    if (offset > 0 && offset < textNodeSize) {
+        const splitNodes = textNode.splitText(offset);
+        if (splitNodes.length === 0) {
+            return null;
+        }
+        // The split node is the first node in splitNodes (the part after the split)
+        const splitTextNode = splitNodes[0];
+        if (!splitTextNode) {
+            return null;
+        }
+        // Create a new paragraph and move all nodes after the split point to it
+        const newParagraph = $createParagraphNode();
+        // Get all nodes from the paragraph that should move to the new paragraph
+        const nodesToMove = [];
+        const updatedChildren = paragraph.getChildren();
+        // Find the first node that should be moved (the split text node)
+        for (let i = 0; i < updatedChildren.length; i++) {
+            const child = updatedChildren[i];
+            if (child === splitTextNode) {
+                // Found the split point - move this node and all subsequent nodes
+                for (let j = i; j < updatedChildren.length; j++) {
+                    const nodeToMove = updatedChildren[j];
+                    if (nodeToMove) {
+                        nodesToMove.push(nodeToMove);
+                    }
+                }
+                break;
+            }
+        }
+        // Move nodes to the new paragraph
+        if (nodesToMove.length > 0) {
+            nodesToMove.forEach((node) => {
+                node.remove();
+                newParagraph.append(node);
+            });
+            // Insert the new paragraph after the original paragraph
+            paragraph.insertAfter(newParagraph);
+            return splitTextNode;
+        }
+    }
+    return null;
+}

package/dist/lib/lexical/sync-plugin.d.ts

@@ -0,0 +1,11 @@
+interface SyncPluginProps {
+    value: string;
+    initialValueRef: React.MutableRefObject<string>;
+}
+/**
+ * Plugin that syncs external value changes with the editor.
+ * Handles cases where the value prop changes from outside the editor.
+ */
+export declare function SyncPlugin({ value, initialValueRef }: SyncPluginProps): null;
+export {};
+//# sourceMappingURL=sync-plugin.d.ts.map

package/dist/lib/lexical/sync-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-plugin.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/sync-plugin.tsx"],"names":[],"mappings":"AAWA,UAAU,eAAe;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,eAAe,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAChD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,EAAE,eAAe,GAAG,IAAI,CAsC5E"}