@liminis/editor 0.1.0-rc.1

package/dist/app/editor/Editor.js

@@ -0,0 +1,539 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useMemo, useState, lazy, Suspense } from 'react';
+import { LexicalComposer } from '@lexical/react/LexicalComposer';
+import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin';
+import { ContentEditable } from '@lexical/react/LexicalContentEditable';
+import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin';
+import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin';
+import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
+import { ListPlugin } from '@lexical/react/LexicalListPlugin';
+import { CheckListPlugin } from '@lexical/react/LexicalCheckListPlugin';
+import { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin';
+import { LinkPlugin } from '@lexical/react/LexicalLinkPlugin';
+import { TablePlugin } from '@lexical/react/LexicalTablePlugin';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $isCodeNode } from '@lexical/code';
+import { registerCodeHighlighting } from '@lexical/code-prism';
+import { $createParagraphNode, $createRangeSelection, $getRoot, $getSelection, $isElementNode, $isLineBreakNode, $isRangeSelection, $isTextNode, $setSelection, COMMAND_PRIORITY_LOW, KEY_ENTER_COMMAND, } from 'lexical';
+import { mergeRegister } from '@lexical/utils';
+import { Toolbar } from './Toolbar.js';
+import { SlashMenuPlugin } from './SlashMenuPlugin.js';
+import { DragHandlePlugin } from './DragHandlePlugin.js';
+import { MarkdownShortcutsPlugin } from './MarkdownShortcutsPlugin.js';
+import { TableActionsPlugin } from './TableActionsPlugin.js';
+import { CodeBlockPlugin } from './CodeBlockPlugin.js';
+import { TogglePlugin } from './TogglePlugin.js';
+import { ImagePlugin } from './ImagePlugin.js';
+import { BlockClickPlugin } from './BlockClickPlugin.js';
+import { LinkClickPlugin } from './LinkClickPlugin.js';
+import { OrderedTaskListPlugin } from './OrderedTaskListPlugin.js';
+import { SearchPlugin } from './SearchPlugin.js';
+import { FrontmatterPlugin } from './FrontmatterPlugin.js';
+import { WikiLinkExistencePlugin } from './WikiLinkExistencePlugin.js';
+import { WikiLinkFormatPlugin } from './WikiLinkFormatPlugin.js';
+import { AnchorScrollPlugin } from './AnchorScrollPlugin.js';
+import { SelectionContextMenuPlugin } from './SelectionContextMenuPlugin.js';
+import { CorrectionPanelPlugin } from './CorrectionPanelPlugin.js';
+import { AmbientCorrectionPlugin } from './AmbientCorrectionPlugin.js';
+import { AssetContext, createAssetContextValue } from './AssetContext.js';
+import { editorNodes } from './editorNodes.js';
+import { importMarkdownToLexicalInEditorStateWithOffsets, importMarkdownToLexicalWithOffsets, } from '../mapper/mdastToLexical.js';
+import { exportLexicalToMdast } from '../mapper/lexicalToMdast.js';
+import { parseMarkdown } from '../../markdown/parse.js';
+import { stringifyMarkdown } from '../../markdown/stringify.js';
+/**
+ * The annotation feature surface, loaded only when a host configures at least
+ * one kind. A static import here would defeat FR-004: every consumer would
+ * pull the annotation modules into its graph whether or not it uses them.
+ */
+const LazyAnnotationSurface = lazy(() => import('./AnnotationSurface.js'));
+/** Stable identity, so an unconfigured `annotations` prop doesn't re-render the surface. */
+const EMPTY_ANNOTATIONS = [];
+const editorTheme = {
+    paragraph: 'editor-paragraph',
+    heading: {
+        h1: 'editor-heading-h1',
+        h2: 'editor-heading-h2',
+        h3: 'editor-heading-h3',
+        h4: 'editor-heading-h4',
+        h5: 'editor-heading-h5',
+    },
+    list: {
+        ul: 'editor-list-ul',
+        ol: 'editor-list-ol',
+        listitem: 'editor-listitem',
+        listitemChecked: 'editor-listitem-checked',
+        listitemUnchecked: 'editor-listitem-unchecked',
+        nested: {
+            listitem: 'editor-nested-listitem',
+        },
+    },
+    quote: 'editor-quote',
+    code: 'editor-code',
+    codeHighlight: {
+        atrule: 'editor-tokenAttr',
+        attr: 'editor-tokenAttr',
+        boolean: 'editor-tokenProperty',
+        builtin: 'editor-tokenSelector',
+        cdata: 'editor-tokenComment',
+        char: 'editor-tokenSelector',
+        class: 'editor-tokenFunction',
+        'class-name': 'editor-tokenFunction',
+        comment: 'editor-tokenComment',
+        constant: 'editor-tokenProperty',
+        deleted: 'editor-tokenProperty',
+        doctype: 'editor-tokenComment',
+        entity: 'editor-tokenOperator',
+        function: 'editor-tokenFunction',
+        important: 'editor-tokenVariable',
+        inserted: 'editor-tokenSelector',
+        keyword: 'editor-tokenAttr',
+        namespace: 'editor-tokenVariable',
+        number: 'editor-tokenProperty',
+        operator: 'editor-tokenOperator',
+        prolog: 'editor-tokenComment',
+        property: 'editor-tokenProperty',
+        punctuation: 'editor-tokenPunctuation',
+        regex: 'editor-tokenVariable',
+        selector: 'editor-tokenSelector',
+        string: 'editor-tokenSelector',
+        symbol: 'editor-tokenProperty',
+        tag: 'editor-tokenProperty',
+        url: 'editor-tokenOperator',
+        variable: 'editor-tokenVariable',
+    },
+    link: 'editor-link',
+    table: 'editor-table',
+    tableRow: 'editor-table-row',
+    tableCell: 'editor-table-cell',
+    tableCellHeader: 'editor-table-cell-header',
+    text: {
+        bold: 'editor-text-bold',
+        italic: 'editor-text-italic',
+        strikethrough: 'editor-text-strikethrough',
+        code: 'editor-text-code',
+        underline: 'editor-text-underline',
+    },
+};
+function editorOnError(error) {
+    console.error('Lexical error:', error);
+}
+// Mirror of $exitCodeNodeOnEnter in @lexical/code-core@0.44 (CodeExtension.register).
+// CodePrismExtension requires LexicalExtensionComposer which is incompatible with
+// LexicalComposer, so the Enter×3 escape logic is wired here instead.
+// Re-verify against upstream when bumping @lexical/code past 0.44 (#8360).
+function $exitCodeBlockOnEnter(selection) {
+    const { anchor } = selection;
+    if (!selection.isCollapsed() || anchor.type !== 'element')
+        return false;
+    const codeNode = anchor.getNode();
+    if (!$isCodeNode(codeNode))
+        return false;
+    const childrenSize = codeNode.getChildrenSize();
+    if (childrenSize < 2 || anchor.offset !== childrenSize)
+        return false;
+    const lastChild = codeNode.getLastChild();
+    if (!$isLineBreakNode(lastChild) || !$isLineBreakNode(lastChild.getPreviousSibling()))
+        return false;
+    const newElement = $createParagraphNode();
+    codeNode.splice(childrenSize - 2, 2, []).insertAfter(newElement, false);
+    newElement.select();
+    return true;
+}
+// Plugin to enable syntax highlighting in code blocks and wire the Enter×3 escape
+// handler that moved to CodeExtension in Lexical 0.44 (#8360).
+function CodeHighlightPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        return mergeRegister(registerCodeHighlighting(editor), editor.registerCommand(KEY_ENTER_COMMAND, (event) => {
+            const selection = $getSelection();
+            if (!$isRangeSelection(selection) || !$exitCodeBlockOnEnter(selection))
+                return false;
+            event?.preventDefault();
+            return true;
+        }, COMMAND_PRIORITY_LOW));
+    }, [editor]);
+    return null;
+}
+// Plugin to initialize editor with markdown content
+function InitializePlugin({ content, onOffsets, }) {
+    const [editor] = useLexicalComposerContext();
+    const hasInitialized = useRef(false);
+    useEffect(() => {
+        if (hasInitialized.current)
+            return;
+        hasInitialized.current = true;
+        if (content) {
+            const { root } = parseMarkdown(content);
+            onOffsets(importMarkdownToLexicalWithOffsets(editor, root), content);
+        }
+    }, [editor, content, onOffsets]);
+    return null;
+}
+// Plugin to auto-focus the editor when it mounts
+function AutoFocusPlugin() {
+    const [editor] = useLexicalComposerContext();
+    const hasFocused = useRef(false);
+    useEffect(() => {
+        if (hasFocused.current)
+            return;
+        hasFocused.current = true;
+        // Small delay to ensure the editor is fully ready
+        const timeoutId = setTimeout(() => {
+            const rootElement = editor.getRootElement();
+            if (rootElement) {
+                // Focus without scrolling
+                rootElement.focus({ preventScroll: true });
+            }
+        }, 100);
+        return () => clearTimeout(timeoutId);
+    }, [editor]);
+    return null;
+}
+// Plugin to handle dynamic editable state changes
+function EditablePlugin({ editable }) {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        editor.setEditable(editable);
+    }, [editor, editable]);
+    return null;
+}
+// Plugin to track cursor position and report to parent
+function CursorTrackingPlugin({ onCursorChange, }) {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        if (!onCursorChange)
+            return;
+        return editor.registerUpdateListener(({ editorState }) => {
+            editorState.read(() => {
+                const selection = $getSelection();
+                if (!$isRangeSelection(selection))
+                    return;
+                const offset = getGlobalOffsetForPoint(selection.anchor);
+                if (offset === null)
+                    return;
+                const textContent = $getRoot().getTextContent();
+                const CONTEXT_CHARS = 50;
+                const contextBefore = textContent.slice(Math.max(0, offset - CONTEXT_CHARS), offset);
+                const contextAfter = textContent.slice(offset, Math.min(textContent.length, offset + CONTEXT_CHARS));
+                onCursorChange({
+                    offset,
+                    contextBefore,
+                    contextAfter,
+                });
+            });
+        });
+    }, [editor, onCursorChange]);
+    return null;
+}
+// Plugin to restore cursor after content reload
+function CursorRestorePlugin({ contentVersion, cursorToRestoreRef, }) {
+    const [editor] = useLexicalComposerContext();
+    const lastRestoredVersion = useRef(contentVersion);
+    useEffect(() => {
+        // Only restore when contentVersion actually changes (content was reloaded)
+        if (contentVersion === lastRestoredVersion.current)
+            return;
+        lastRestoredVersion.current = contentVersion;
+        // Read ref value inside effect, not during render
+        const cursorToRestore = cursorToRestoreRef.current;
+        if (!cursorToRestore)
+            return;
+        console.log('[CursorRestorePlugin] Restoring cursor', {
+            contentVersion,
+            offset: cursorToRestore.offset,
+        });
+        // Delay slightly to ensure content has been imported
+        requestAnimationFrame(() => {
+            editor.update(() => {
+                const root = $getRoot();
+                const textContent = root.getTextContent();
+                // Try to find cursor position using context
+                let newOffset = findOffsetByContext(textContent, cursorToRestore.offset, cursorToRestore.contextBefore, cursorToRestore.contextAfter);
+                // Clamp to valid range
+                newOffset = Math.max(0, Math.min(textContent.length, newOffset));
+                const point = findTextPointAtOffset(root, newOffset);
+                if (point) {
+                    const selection = $createRangeSelection();
+                    selection.anchor.set(point.key, point.offset, 'text');
+                    selection.focus.set(point.key, point.offset, 'text');
+                    $setSelection(selection);
+                    console.log('[CursorRestorePlugin] Selection restored at offset', newOffset);
+                }
+            });
+            // Re-focus the editor
+            const rootElement = editor.getRootElement();
+            if (rootElement) {
+                rootElement.focus({ preventScroll: true });
+            }
+        });
+    }, [editor, contentVersion, cursorToRestoreRef]);
+    return null;
+}
+// Find best matching offset using context strings
+function findOffsetByContext(text, fallbackOffset, contextBefore, contextAfter) {
+    // Try to find the exact junction of before+after context
+    if (contextBefore && contextAfter) {
+        const combined = contextBefore + contextAfter;
+        const idx = text.indexOf(combined);
+        if (idx !== -1) {
+            return idx + contextBefore.length;
+        }
+    }
+    // Try to find just the before context (cursor at end of it)
+    if (contextBefore.length >= 10) {
+        const idx = text.indexOf(contextBefore);
+        if (idx !== -1) {
+            return idx + contextBefore.length;
+        }
+    }
+    // Try to find just the after context (cursor at start of it)
+    if (contextAfter.length >= 10) {
+        const idx = text.indexOf(contextAfter);
+        if (idx !== -1) {
+            return idx;
+        }
+    }
+    // Fallback to absolute offset (clamped)
+    return fallbackOffset;
+}
+// Plugin to handle content updates from extension host
+// This should ONLY reload when content comes from external source (file open/reload)
+// NOT when content flows back from editor's own onChange
+function ExternalUpdatePlugin({ content, lastExternalLoadRef, currentContentRef, lastEditorChangeRef, onOffsets, }) {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        // Skip if content matches what we already have
+        if (content === currentContentRef.current) {
+            return;
+        }
+        // Skip if this change likely came from the editor itself (via onChange callback)
+        // This prevents the feedback loop: type -> onChange -> prop change -> reload
+        const timeSinceEditorChange = Date.now() - lastEditorChangeRef.current;
+        if (timeSinceEditorChange < POST_LOAD_SUPPRESS_MS) {
+            // Still update the ref so we don't reload on next render either
+            currentContentRef.current = content;
+            return;
+        }
+        console.log('[ExternalUpdatePlugin] Reloading content', {
+            contentLen: content.length,
+            currentLen: currentContentRef.current.length,
+        });
+        // Mark that we're loading external content
+        lastExternalLoadRef.current = Date.now();
+        currentContentRef.current = content;
+        // Defer the editor update to avoid React's flushSync warning
+        // This moves the Lexical update out of React's commit phase
+        queueMicrotask(() => {
+            // Double-check content still needs updating (user might have typed during microtask)
+            if (content !== currentContentRef.current) {
+                console.log('[ExternalUpdatePlugin] Skipping stale reload');
+                return;
+            }
+            const { root } = parseMarkdown(content);
+            let spans = [];
+            editor.update(() => {
+                spans = importMarkdownToLexicalInEditorStateWithOffsets(root);
+            }, { discrete: true });
+            onOffsets(spans, content);
+        });
+    }, [editor, content, lastExternalLoadRef, currentContentRef, lastEditorChangeRef, onOffsets]);
+    return null;
+}
+// Convert a Lexical selection point to a global character offset
+function getGlobalOffsetForPoint(point) {
+    const root = $getRoot();
+    let currentOffset = 0;
+    let found = false;
+    const walk = (node) => {
+        if (found)
+            return;
+        if (node.getKey() === point.key) {
+            if ($isTextNode(node)) {
+                currentOffset += Math.min(point.offset, node.getTextContent().length);
+                found = true;
+                return;
+            }
+            if ($isElementNode(node)) {
+                const children = node.getChildren();
+                const limit = Math.min(point.offset, children.length);
+                for (let i = 0; i < limit; i += 1) {
+                    currentOffset += children[i].getTextContent().length;
+                }
+                found = true;
+                return;
+            }
+        }
+        if ($isTextNode(node)) {
+            currentOffset += node.getTextContent().length;
+            return;
+        }
+        if ($isElementNode(node)) {
+            for (const child of node.getChildren()) {
+                walk(child);
+                if (found)
+                    return;
+            }
+        }
+    };
+    walk(root);
+    return found ? currentOffset : null;
+}
+// Find a text node and offset for a given global character offset
+function findTextPointAtOffset(root, offset) {
+    const textNodes = root.getAllTextNodes();
+    if (textNodes.length === 0) {
+        return null;
+    }
+    let remaining = Math.max(0, offset);
+    for (const node of textNodes) {
+        const length = node.getTextContent().length;
+        if (remaining <= length) {
+            return { key: node.getKey(), offset: remaining };
+        }
+        remaining -= length;
+    }
+    const lastNode = textNodes[textNodes.length - 1];
+    return { key: lastNode.getKey(), offset: lastNode.getTextContent().length };
+}
+// Debounce delay in ms - balances responsiveness with performance
+const DEBOUNCE_DELAY = 100;
+// Window after an external content load (file open/reload) or editor-initiated change
+// during which we suppress onChange/reload to avoid feedback loops and normalization noise.
+const POST_LOAD_SUPPRESS_MS = 500;
+export function Editor({ initialContent, autoFocus = false, contentVersion = 0, cursorToRestoreRef, onChange, onCursorChange, onSelectionContextMenu, assetBaseUri, documentDirUri, imagePathResolution, wikiLinkPromotion, resolveLocalAsset, editable = true, filePath, onSubstitutionDetected, sweepRef, annotationKinds, annotations, activeAnnotationId = null, scrollToAnnotation, onCreateAnnotation, onActivateAnnotation, annotationEditorHandleRef, annotationLogger, }) {
+    // Annotations are on only when the host configured at least one kind
+    // (FR-004). Everything annotation-specific hangs off this flag, including
+    // the dynamic import below — with no kinds, none of those modules is ever
+    // loaded and no annotation command is registered.
+    const annotationsEnabled = !!annotationKinds && Object.keys(annotationKinds).length > 0;
+    // Derived, kind-agnostic affordance lists (FR-001/FR-004/FR-009/FR-010):
+    // one entry per configured kind on each surface, label falling back to the
+    // kind name (FR-003). Plain data only, so `Toolbar`/`SelectionContextMenuPlugin`
+    // never need to know about annotation types.
+    const toolbarAnnotationAffordances = useMemo(() => {
+        if (!annotationKinds)
+            return [];
+        return Object.entries(annotationKinds)
+            .filter(([, config]) => config.createAffordance?.surface === 'toolbar')
+            .map(([kind, config]) => ({ kind, label: config.createAffordance?.label ?? kind }));
+    }, [annotationKinds]);
+    const contextMenuAnnotationAffordances = useMemo(() => {
+        if (!annotationKinds)
+            return [];
+        return Object.entries(annotationKinds)
+            .filter(([, config]) => config.createAffordance?.surface === 'contextMenu')
+            .map(([kind, config]) => ({ kind, label: config.createAffordance?.label ?? kind }));
+    }, [annotationKinds]);
+    const offsetSpansRef = useRef([]);
+    const markdownTextRef = useRef(initialContent);
+    const [offsetsVersion, setOffsetsVersion] = useState(0);
+    // Read inside `handleOffsets` rather than closed over, so the callback's
+    // identity stays stable — it is an effect dependency in `InitializePlugin`
+    // and `ExternalUpdatePlugin`, and a new identity there would re-run them.
+    const annotationsEnabledRef = useRef(annotationsEnabled);
+    annotationsEnabledRef.current = annotationsEnabled;
+    /**
+     * Records the offset table each (re)parse produces.
+     *
+     * The two ref writes are unconditional on purpose. `InitializePlugin` runs
+     * its import exactly once, so gating span collection on `annotationsEnabled`
+     * left a host that loads its kinds asynchronously with a permanently empty
+     * table and silently placed nothing (an earlier review finding). The cost is
+     * one small record per text node on a walk that already visits every node.
+     *
+     * The `offsetsVersion` bump, on the other hand, is a state update that
+     * re-renders `Editor` — so it is gated. With annotations off nothing
+     * consumes the version, and a host that never passes `annotationKinds`
+     * should not re-render on every parse and external reload to maintain a
+     * counter nobody reads (review finding, @handarbeit-pruefer). When kinds
+     * arrive later, `AnnotationSurface` mounts and its placement effect runs
+     * against the refs, which are already current.
+     */
+    const handleOffsets = useCallback((spans, markdownText) => {
+        offsetSpansRef.current = spans;
+        markdownTextRef.current = markdownText;
+        if (annotationsEnabledRef.current)
+            setOffsetsVersion((v) => v + 1);
+    }, []);
+    const lastExternalLoadRef = useRef(0);
+    const currentContentRef = useRef(initialContent);
+    const debounceTimerRef = useRef(null);
+    const pendingEditorRef = useRef(null);
+    // Track when editor-initiated changes happen to prevent feedback loops
+    const lastEditorChangeRef = useRef(0);
+    // Fallback ref for cursor restore when not provided
+    const fallbackCursorRef = useRef(null);
+    const effectiveCursorRef = cursorToRestoreRef ?? fallbackCursorRef;
+    const assetContextValue = useMemo(() => createAssetContextValue({ assetBaseUri, documentDirUri, imagePathResolution, resolveLocalAsset }), [assetBaseUri, documentDirUri, imagePathResolution, resolveLocalAsset]);
+    // Keep a ref to onChange so the unmount flush always calls the latest handler
+    // without causing the effect to re-run (and spuriously flush) on re-renders.
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    // Same reasoning as onChangeRef: flushPendingChange must stay a stable
+    // ([]) callback, so the latest prop value is read through a ref rather than
+    // closed over.
+    const wikiLinkPromotionRef = useRef(wikiLinkPromotion);
+    wikiLinkPromotionRef.current = wikiLinkPromotion;
+    // Export pending editor state and propagate if changed.
+    // Shared by the debounce timer callback and unmount flush.
+    const flushPendingChange = useCallback(() => {
+        const pendingEditor = pendingEditorRef.current;
+        if (!pendingEditor)
+            return;
+        const timeSinceLoad = Date.now() - lastExternalLoadRef.current;
+        if (timeSinceLoad < POST_LOAD_SUPPRESS_MS)
+            return;
+        const mdast = exportLexicalToMdast(pendingEditor, { wikiLinkPromotion: wikiLinkPromotionRef.current });
+        const markdown = stringifyMarkdown(mdast);
+        if (markdown !== currentContentRef.current) {
+            currentContentRef.current = markdown;
+            lastEditorChangeRef.current = Date.now();
+            onChangeRef.current(markdown);
+        }
+    }, []);
+    // Flush pending debounced change on unmount so we don't lose edits
+    // (e.g. when switching from WYSIWYG to raw text view)
+    useEffect(() => {
+        return () => {
+            if (debounceTimerRef.current !== null) {
+                clearTimeout(debounceTimerRef.current);
+                debounceTimerRef.current = null;
+                flushPendingChange();
+            }
+        };
+    }, [flushPendingChange]);
+    const handleChange = useCallback((editorState, editor) => {
+        void editorState;
+        // Skip changes that happen right after external content load
+        // These are normalization diffs, not user edits
+        const timeSinceExternalLoad = Date.now() - lastExternalLoadRef.current;
+        if (timeSinceExternalLoad < POST_LOAD_SUPPRESS_MS) {
+            return;
+        }
+        // Store the latest editor for debounced processing
+        pendingEditorRef.current = editor;
+        // Clear existing timer
+        if (debounceTimerRef.current !== null) {
+            clearTimeout(debounceTimerRef.current);
+        }
+        // Debounce the expensive mdast conversion
+        debounceTimerRef.current = window.setTimeout(() => {
+            debounceTimerRef.current = null;
+            flushPendingChange();
+        }, DEBOUNCE_DELAY);
+    }, [flushPendingChange]);
+    const initialConfig = {
+        namespace: 'SlashMD',
+        theme: editorTheme,
+        nodes: editorNodes,
+        onError: editorOnError,
+        editable,
+    };
+    return (_jsx(AssetContext.Provider, { value: assetContextValue, children: _jsx(LexicalComposer, { initialConfig: initialConfig, children: _jsx("div", { className: "relative max-w-[800px] ml-5 mr-1 pl-6 pr-6", children: _jsxs("div", { className: "editor-inner relative", children: [_jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: "editor-input", "aria-label": "Markdown editor" }), placeholder: _jsx("div", { className: "editor-placeholder", children: "Type '/' for commands..." }), ErrorBoundary: LexicalErrorBoundary }), _jsx(HistoryPlugin, {}), _jsx(ListPlugin, {}), _jsx(CheckListPlugin, {}), _jsx(OrderedTaskListPlugin, {}), _jsx(TabIndentationPlugin, {}), _jsx(LinkPlugin, {}), _jsx(TablePlugin, {}), _jsx(CodeHighlightPlugin, {}), _jsx(OnChangePlugin, { onChange: handleChange, ignoreSelectionChange: true }), _jsx(InitializePlugin, { content: initialContent, onOffsets: handleOffsets }), _jsx(EditablePlugin, { editable: editable }), autoFocus && _jsx(AutoFocusPlugin, {}), _jsx(CursorTrackingPlugin, { onCursorChange: onCursorChange }), _jsx(CursorRestorePlugin, { contentVersion: contentVersion, cursorToRestoreRef: effectiveCursorRef }), _jsx(ExternalUpdatePlugin, { content: initialContent, lastExternalLoadRef: lastExternalLoadRef, currentContentRef: currentContentRef, lastEditorChangeRef: lastEditorChangeRef, onOffsets: handleOffsets }), _jsx(SlashMenuPlugin, {}), _jsx(DragHandlePlugin, {}), _jsx(MarkdownShortcutsPlugin, {}), _jsx(TableActionsPlugin, {}), _jsx(CodeBlockPlugin, {}), _jsx(TogglePlugin, {}), _jsx(ImagePlugin, {}), _jsx(BlockClickPlugin, {}), _jsx(LinkClickPlugin, { editable: editable }), _jsx(Toolbar, { annotationAffordances: toolbarAnnotationAffordances }), _jsx(SearchPlugin, {}), _jsx(FrontmatterPlugin, { filePath: filePath }), _jsx(WikiLinkExistencePlugin, {}), _jsx(WikiLinkFormatPlugin, {}), _jsx(AnchorScrollPlugin, {}), _jsx(SelectionContextMenuPlugin, { onSelectionContextMenu: onSelectionContextMenu, 
+                            // Only kinds that actually ask for a context-menu affordance:
+                            // with none configured, or one on another surface, AnnotationPlugin
+                            // would decline the command anyway, and dispatching from here would
+                            // claim an entry point the kind never opted into.
+                            annotationAffordances: contextMenuAnnotationAffordances }), _jsx(CorrectionPanelPlugin, {}), onSubstitutionDetected && (_jsx(AmbientCorrectionPlugin, { onSubstitutionDetected: onSubstitutionDetected, sweepRef: sweepRef })), annotationsEnabled && (_jsx(Suspense, { fallback: null, children: _jsx(LazyAnnotationSurface, { kinds: annotationKinds, annotations: annotations ?? EMPTY_ANNOTATIONS, activeAnnotationId: activeAnnotationId, scrollToAnnotation: scrollToAnnotation, onCreateAnnotation: onCreateAnnotation, onActivateAnnotation: onActivateAnnotation, editorHandleRef: annotationEditorHandleRef, offsetSpansRef: offsetSpansRef, markdownTextRef: markdownTextRef, offsetsVersion: offsetsVersion, logger: annotationLogger, wikiLinkPromotion: wikiLinkPromotion }) }))] }) }) }) }));
+}

package/dist/app/editor/FrontmatterPlugin.d.ts

@@ -0,0 +1,19 @@
+/**
+ * FrontmatterPlugin - Shows frontmatter in a collapsible tray overlay
+ *
+ * The actual FrontmatterNode is hidden via CSS but remains in the Lexical tree.
+ * This plugin provides a UI to view/edit frontmatter in a sliding tray.
+ *
+ * The toggle button is rendered externally (in the editor header).
+ * This plugin communicates via Zustand store for state management.
+ *
+ * For .mdc files (Cursor rules), a specialized form UI is shown with:
+ * - alwaysApply dropdown (true/false)
+ * - description text input
+ * - globs array editor
+ */
+interface FrontmatterPluginProps {
+    filePath?: string;
+}
+export declare function FrontmatterPlugin({ filePath }: FrontmatterPluginProps): import("react").JSX.Element | null;
+export {};