@liminis/editor 0.1.0-rc.1

package/dist/app/editor/Toolbar.js

@@ -0,0 +1,263 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState, useRef } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getSelection, $isRangeSelection, FORMAT_TEXT_COMMAND, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_LOW, } from 'lexical';
+import { $isLinkNode, TOGGLE_LINK_COMMAND } from '@lexical/link';
+import { getSelectedNode } from './utils.js';
+import { OPEN_ANNOTATION_COMPOSER_COMMAND } from './annotationCommands.js';
+const initialToolbarState = {
+    isVisible: false,
+    isBold: false,
+    isItalic: false,
+    isStrikethrough: false,
+    isCode: false,
+    isLink: false,
+    position: { top: 0, left: 0 },
+    showLinkInput: false,
+    linkUrl: '',
+};
+export function Toolbar({ annotationAffordances = [] }) {
+    const [editor] = useLexicalComposerContext();
+    const [state, setState] = useState(initialToolbarState);
+    const [editable, setEditable] = useState(editor.isEditable());
+    const linkInputRef = useRef(null);
+    const toolbarRef = useRef(null);
+    const dismissedByClickRef = useRef(false);
+    // Visibility + position, sourced from the native browser selection rather
+    // than Lexical's. Lexical never reports a range selection on a
+    // non-editable root, and doesn't reliably dispatch SELECTION_CHANGE_COMMAND
+    // for a double-click word-selection even when editable — window.getSelection()
+    // is accurate in both cases, matching AnnotationPlugin's own capture path.
+    const updateVisibility = useCallback(() => {
+        // Don't show toolbar if it was just dismissed by clicking outside
+        if (dismissedByClickRef.current) {
+            return;
+        }
+        // Don't hide the toolbar while focus is inside it. Opening the link
+        // input moves focus (and therefore the native selection) away from the
+        // editor root the instant it appears, which would otherwise look
+        // identical to "selection left the editor" and close the input the user
+        // just opened.
+        if (toolbarRef.current && document.activeElement && toolbarRef.current.contains(document.activeElement)) {
+            return;
+        }
+        const nativeSelection = window.getSelection();
+        const rootElement = editor.getRootElement();
+        // Both endpoints, not just one, must be inside the root — a selection
+        // that only partially overlaps the editor (e.g. a drag starting in
+        // surrounding page content and ending inside this editor) is deliberately
+        // treated as "outside," not shown. AnnotationPlugin's capture wraps the
+        // live native range directly in a Lexical mark; letting the toolbar
+        // appear for a range that reaches outside the editor's own DOM would
+        // make that affordance reachable for a selection capture was never
+        // designed to wrap.
+        if (!nativeSelection ||
+            nativeSelection.rangeCount === 0 ||
+            nativeSelection.isCollapsed ||
+            !rootElement ||
+            !nativeSelection.anchorNode ||
+            !nativeSelection.focusNode ||
+            !rootElement.contains(nativeSelection.anchorNode) ||
+            !rootElement.contains(nativeSelection.focusNode)) {
+            setState(prev => prev.isVisible ? { ...prev, isVisible: false } : prev);
+            return;
+        }
+        const range = nativeSelection.getRangeAt(0);
+        const rect = range.getBoundingClientRect();
+        setState(prev => ({
+            ...prev,
+            isVisible: true,
+            position: {
+                top: rect.top - 45,
+                left: rect.left + rect.width / 2,
+            },
+        }));
+    }, [editor]);
+    // Format-flag booleans (bold/italic/strikethrough/code/link) stay sourced
+    // from Lexical's own selection, exactly as before — only computed while
+    // editable, since the controls that display them don't render otherwise.
+    // Must be called from inside an editor state read.
+    //
+    // Known limitation: this reads whatever Lexical's own $getSelection() last
+    // reconciled, which Lexical updates from the native selection via its own
+    // pointerdown-gated sync (see the native selectionchange listener below).
+    // A genuine double-click always fires a real pointerdown first, so it
+    // reconciles correctly; a selection change with no preceding pointerdown
+    // on this root leaves these flags at their last-known value rather than
+    // the newly-selected text's actual formatting (see the regression test
+    // "format flags after a native-only selection with no preceding
+    // pointerdown"). Deriving these flags any other way would mean
+    // re-implementing bold/italic/link detection from raw DOM instead of
+    // Lexical's model, which is out of scope per the spec's Assumptions.
+    const updateFormatFlags = useCallback(() => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection) || selection.isCollapsed()) {
+            return;
+        }
+        const node = getSelectedNode(selection);
+        const parent = node.getParent();
+        const isLink = $isLinkNode(parent) || $isLinkNode(node);
+        setState(prev => ({
+            ...prev,
+            isBold: selection.hasFormat('bold'),
+            isItalic: selection.hasFormat('italic'),
+            isStrikethrough: selection.hasFormat('strikethrough'),
+            isCode: selection.hasFormat('code'),
+            isLink,
+        }));
+    }, []);
+    // A selection can already be live when `editable` flips true (e.g. a
+    // reviewer had bold text selected read-only, then the host makes the
+    // document editable) — format flags must be recomputed on that transition,
+    // not just left at their stale/default value until the next selection change.
+    useEffect(() => {
+        return editor.registerEditableListener((isEditable) => {
+            setEditable(isEditable);
+            if (isEditable) {
+                editor.getEditorState().read(() => {
+                    updateFormatFlags();
+                });
+            }
+        });
+    }, [editor, updateFormatFlags]);
+    useEffect(() => {
+        const unregisterSelection = editor.registerCommand(SELECTION_CHANGE_COMMAND, () => {
+            updateVisibility();
+            if (editor.isEditable()) {
+                editor.getEditorState().read(() => {
+                    updateFormatFlags();
+                });
+            }
+            return false;
+        }, COMMAND_PRIORITY_CRITICAL);
+        // Also listen for format changes to update button states
+        const unregisterFormat = editor.registerCommand(FORMAT_TEXT_COMMAND, () => {
+            // Defer the update to run after the format is applied
+            setTimeout(() => {
+                if (editor.isEditable()) {
+                    editor.getEditorState().read(() => {
+                        updateFormatFlags();
+                    });
+                }
+            }, 0);
+            return false;
+        }, COMMAND_PRIORITY_LOW);
+        return () => {
+            unregisterSelection();
+            unregisterFormat();
+        };
+    }, [editor, updateVisibility, updateFormatFlags]);
+    // Native selectionchange fires for every selection the browser makes,
+    // including a non-editable root and a double-click word-selection — neither
+    // of which reliably drives SELECTION_CHANGE_COMMAND (FR-001/FR-002).
+    //
+    // For a normal drag-selection while editable, this listener and the
+    // SELECTION_CHANGE_COMMAND handler above both fire for the same underlying
+    // browser event (Lexical's own command is itself dispatched from its
+    // internal selectionchange handling), so a single real selection change
+    // runs updateVisibility/updateFormatFlags twice. This is intentional, not
+    // an oversight: both computations are idempotent (same selection in ⇒ same
+    // state out), the extra pass is cheap, and de-duplicating the two triggers
+    // would mean re-introducing a way to tell "did SELECTION_CHANGE_COMMAND
+    // already run for this event" — more state to get wrong than the
+    // duplicate, harmless recompute it would save.
+    useEffect(() => {
+        const handleNativeSelectionChange = () => {
+            updateVisibility();
+            if (editor.isEditable()) {
+                editor.getEditorState().read(() => {
+                    updateFormatFlags();
+                });
+            }
+        };
+        document.addEventListener('selectionchange', handleNativeSelectionChange);
+        return () => document.removeEventListener('selectionchange', handleNativeSelectionChange);
+    }, [editor, updateVisibility, updateFormatFlags]);
+    // Dismiss toolbar immediately on mousedown outside
+    useEffect(() => {
+        const handleMouseDown = (e) => {
+            // If toolbar is not visible, nothing to do
+            if (!state.isVisible)
+                return;
+            // If click is inside the toolbar, don't dismiss
+            if (toolbarRef.current?.contains(e.target)) {
+                return;
+            }
+            // Set flag to prevent selection change from re-showing toolbar
+            dismissedByClickRef.current = true;
+            // Dismiss immediately
+            setState(prev => ({ ...prev, isVisible: false, showLinkInput: false }));
+            // Reset flag after selection events have settled
+            setTimeout(() => {
+                dismissedByClickRef.current = false;
+            }, 100);
+        };
+        document.addEventListener('mousedown', handleMouseDown);
+        return () => document.removeEventListener('mousedown', handleMouseDown);
+    }, [state.isVisible]);
+    const formatText = useCallback((format) => {
+        editor.dispatchCommand(FORMAT_TEXT_COMMAND, format);
+    }, [editor]);
+    const openLinkInput = useCallback(() => {
+        if (state.isLink) {
+            // Remove link
+            editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+        }
+        else {
+            // Show link input
+            setState(prev => ({ ...prev, showLinkInput: true, linkUrl: '' }));
+            // Focus the input after it renders
+            setTimeout(() => linkInputRef.current?.focus(), 0);
+        }
+    }, [editor, state.isLink]);
+    const submitLink = useCallback(() => {
+        if (state.linkUrl) {
+            editor.dispatchCommand(TOGGLE_LINK_COMMAND, state.linkUrl);
+        }
+        setState(prev => ({ ...prev, showLinkInput: false, linkUrl: '' }));
+    }, [editor, state.linkUrl]);
+    const cancelLink = useCallback(() => {
+        setState(prev => ({ ...prev, showLinkInput: false, linkUrl: '' }));
+    }, []);
+    const createAnnotation = useCallback((kind) => {
+        editor.dispatchCommand(OPEN_ANNOTATION_COMPOSER_COMMAND, { kind });
+    }, [editor]);
+    // Formatting controls are inert on a read-only root, so they never render
+    // there (FR-004); with nothing else to offer, the whole toolbar stays
+    // hidden too (FR-006) rather than rendering an empty bar.
+    if (!state.isVisible || (!editable && annotationAffordances.length === 0))
+        return null;
+    return (_jsxs("div", { ref: toolbarRef, className: "toolbar", style: {
+            position: 'fixed',
+            top: state.position.top,
+            left: state.position.left,
+            transform: 'translateX(-50%)',
+        }, children: [editable && (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", onMouseDown: (e) => {
+                            e.preventDefault();
+                            formatText('bold');
+                        }, className: `toolbar-button ${state.isBold ? 'active' : ''}`, "aria-label": "Bold", title: "Bold (Cmd+B)", children: _jsx("strong", { children: "B" }) }), _jsx("button", { type: "button", onMouseDown: (e) => {
+                            e.preventDefault();
+                            formatText('italic');
+                        }, className: `toolbar-button ${state.isItalic ? 'active' : ''}`, "aria-label": "Italic", title: "Italic (Cmd+I)", children: _jsx("em", { children: "I" }) }), _jsx("button", { type: "button", onMouseDown: (e) => {
+                            e.preventDefault();
+                            formatText('strikethrough');
+                        }, className: `toolbar-button ${state.isStrikethrough ? 'active' : ''}`, "aria-label": "Strikethrough", title: "Strikethrough", children: _jsx("s", { children: "S" }) }), _jsx("button", { type: "button", onMouseDown: (e) => {
+                            e.preventDefault();
+                            formatText('code');
+                        }, className: `toolbar-button ${state.isCode ? 'active' : ''}`, "aria-label": "Code", title: "Inline Code (Cmd+E)", children: '</>' }), _jsx("div", { className: "toolbar-divider" }), _jsx("button", { type: "button", onMouseDown: (e) => {
+                            e.preventDefault();
+                            openLinkInput();
+                        }, className: `toolbar-button ${state.isLink ? 'active' : ''}`, "aria-label": "Link", title: "Link (Cmd+K)", children: "\uD83D\uDD17" }), state.showLinkInput && (_jsx("div", { className: "toolbar-link-input", children: _jsx("input", { ref: linkInputRef, type: "text", placeholder: "Enter URL...", value: state.linkUrl, onChange: (e) => setState(prev => ({ ...prev, linkUrl: e.target.value })), onKeyDown: (e) => {
+                                if (e.key === 'Enter') {
+                                    e.preventDefault();
+                                    submitLink();
+                                }
+                                else if (e.key === 'Escape') {
+                                    e.preventDefault();
+                                    cancelLink();
+                                }
+                            }, onBlur: cancelLink }) }))] })), annotationAffordances.length > 0 && (_jsxs(_Fragment, { children: [editable && _jsx("div", { className: "toolbar-divider" }), annotationAffordances.map(({ kind, label }) => (_jsx("button", { type: "button", onMouseDown: (e) => {
+                            e.preventDefault();
+                            createAnnotation(kind);
+                        }, className: "toolbar-button", "aria-label": label, title: label, children: label }, kind)))] }))] }));
+}

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

@@ -0,0 +1,17 @@
+/**
+ * WikiLinkExistencePlugin - Checks wiki-links and marks broken ones
+ *
+ * This plugin scans for wiki-links in the editor DOM and checks if their
+ * target files exist anywhere in the workspace. Links to non-existent files
+ * get a CSS class applied to render them in red.
+ *
+ * Uses the host-supplied `resolveWikiLinks` service, which handles:
+ * - Directory links (e.g., "entities/teams/") → resolves to index.md or README.md
+ * - File links with extension (e.g., "notes.md") → checks directly
+ * - File links without extension (e.g., "notes") → tries .md, .mdc
+ *
+ * The check is performed:
+ * - When the document is loaded
+ * - When the document content changes (debounced)
+ */
+export declare function WikiLinkExistencePlugin(): null;

package/dist/app/editor/WikiLinkExistencePlugin.js

@@ -0,0 +1,104 @@
+import { useEffect, useRef } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useEditorHost } from '../../host/context.js';
+/**
+ * WikiLinkExistencePlugin - Checks wiki-links and marks broken ones
+ *
+ * This plugin scans for wiki-links in the editor DOM and checks if their
+ * target files exist anywhere in the workspace. Links to non-existent files
+ * get a CSS class applied to render them in red.
+ *
+ * Uses the host-supplied `resolveWikiLinks` service, which handles:
+ * - Directory links (e.g., "entities/teams/") → resolves to index.md or README.md
+ * - File links with extension (e.g., "notes.md") → checks directly
+ * - File links without extension (e.g., "notes") → tries .md, .mdc
+ *
+ * The check is performed:
+ * - When the document is loaded
+ * - When the document content changes (debounced)
+ */
+export function WikiLinkExistencePlugin() {
+    const [editor] = useLexicalComposerContext();
+    const { resolveWikiLinks } = useEditorHost();
+    const checkTimeoutRef = useRef(null);
+    const lastCheckedRef = useRef(new Set());
+    useEffect(() => {
+        const rootElement = editor.getRootElement();
+        if (!rootElement)
+            return;
+        const checkWikiLinks = async () => {
+            // Find all wiki-link elements
+            const wikiLinks = rootElement.querySelectorAll('a[data-wiki-link="true"]');
+            if (wikiLinks.length === 0)
+                return;
+            // Collect unique target paths
+            const targets = new Set();
+            wikiLinks.forEach((link) => {
+                const target = link.getAttribute('data-wiki-target');
+                if (target) {
+                    targets.add(target);
+                }
+            });
+            if (targets.size === 0)
+                return;
+            // Skip if we've already checked these exact targets
+            const targetsArray = Array.from(targets);
+            const targetKey = targetsArray.sort().join('|');
+            if (lastCheckedRef.current.has(targetKey)) {
+                return;
+            }
+            // Use the host-supplied resolver which handles directory links, etc.
+            try {
+                if (!resolveWikiLinks) {
+                    console.warn('[WikiLinkExistencePlugin] resolveWikiLinks host service not available');
+                    return;
+                }
+                // Resolve all wiki-link paths
+                const resolved = await resolveWikiLinks(targetsArray);
+                lastCheckedRef.current.add(targetKey);
+                // Update CSS classes on wiki-links
+                wikiLinks.forEach((link) => {
+                    const target = link.getAttribute('data-wiki-target');
+                    if (target) {
+                        // Link exists if resolver returned a non-null path
+                        const exists = resolved[target] !== null;
+                        if (!exists) {
+                            link.classList.add('editor-link-broken');
+                        }
+                        else {
+                            link.classList.remove('editor-link-broken');
+                        }
+                    }
+                });
+            }
+            catch (err) {
+                console.error('[WikiLinkExistencePlugin] Error checking wiki-link existence', err);
+            }
+        };
+        // Debounced check function
+        const scheduleCheck = () => {
+            if (checkTimeoutRef.current) {
+                clearTimeout(checkTimeoutRef.current);
+            }
+            checkTimeoutRef.current = setTimeout(() => { void checkWikiLinks(); }, 300);
+        };
+        // Initial check
+        scheduleCheck();
+        // Listen for editor updates
+        const unregisterListener = editor.registerUpdateListener(({ dirtyElements, dirtyLeaves }) => {
+            // Only re-check if there were actual changes
+            if (dirtyElements.size > 0 || dirtyLeaves.size > 0) {
+                // Clear the cache when content changes so we re-check
+                lastCheckedRef.current.clear();
+                scheduleCheck();
+            }
+        });
+        return () => {
+            unregisterListener();
+            if (checkTimeoutRef.current) {
+                clearTimeout(checkTimeoutRef.current);
+            }
+        };
+    }, [editor, resolveWikiLinks]);
+    return null;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * WikiLinkFormatPlugin - Applies formatting to wiki links when surrounded by format markers
+ *
+ * This plugin detects patterns like `**[[page]]**` typed during live editing and:
+ * 1. Removes the format markers from the surrounding TextNodes
+ * 2. Applies the format (bold, italic, strikethrough) to the wiki link's text children
+ *
+ * Supports:
+ * - Bold: **[[page]]** or __[[page]]__
+ * - Italic: *[[page]]* or _[[page]]_
+ * - Strikethrough: ~~[[page]]~~
+ * - Nested: ***[[page]]*** (bold + italic)
+ *
+ * The plugin runs as a post-processing step after the markdown shortcuts transforms,
+ * using an update listener to detect and modify the tree.
+ */
+export declare function WikiLinkFormatPlugin(): null;

package/dist/app/editor/WikiLinkFormatPlugin.js

@@ -0,0 +1,203 @@
+import { useEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getRoot, $isTextNode, $isElementNode, } from 'lexical';
+import { $isLinkNode } from '@lexical/link';
+/**
+ * Ordered list of format markers to check.
+ * Order matters: longer markers (e.g., **) must come before shorter ones (e.g., *)
+ * to avoid partial matches.
+ */
+const FORMAT_MARKERS = [
+    { marker: '**', format: 'bold' },
+    { marker: '__', format: 'bold' },
+    { marker: '~~', format: 'strikethrough' },
+    // Single * and _ must come after ** and __
+    { marker: '*', format: 'italic' },
+    { marker: '_', format: 'italic' },
+];
+/**
+ * Detect format markers at the end of a text node and start of another.
+ * Returns the formats that should be applied based on matching markers.
+ *
+ * @param beforeText - Text content of the node before the link
+ * @param afterText - Text content of the node after the link
+ * @returns Array of detected formats with their marker lengths
+ */
+function detectSurroundingFormats(beforeText, afterText) {
+    const detected = [];
+    let remainingBefore = beforeText;
+    let remainingAfter = afterText;
+    // Keep checking for markers until no more matches
+    let foundMatch = true;
+    while (foundMatch) {
+        foundMatch = false;
+        for (const { marker, format } of FORMAT_MARKERS) {
+            // Check if before ends with marker and after starts with marker
+            if (remainingBefore.endsWith(marker) && remainingAfter.startsWith(marker)) {
+                // Ensure we're not matching partial markers
+                // e.g., don't match single * when we're actually looking at **
+                // For single char markers (* and _), ensure we're not part of a double marker
+                if (marker.length === 1) {
+                    const beforeIndex = remainingBefore.length - marker.length - 1;
+                    const afterIndex = marker.length;
+                    // If the character before our marker is the same, skip (it's part of ** or __)
+                    const isDoubleBefore = beforeIndex >= 0 && remainingBefore[beforeIndex] === marker;
+                    // If the character after the closing marker is the same, skip
+                    const isDoubleAfter = afterIndex < remainingAfter.length && remainingAfter[afterIndex] === marker;
+                    if (isDoubleBefore || isDoubleAfter)
+                        continue;
+                }
+                detected.push({ format, markerLength: marker.length });
+                remainingBefore = remainingBefore.slice(0, -marker.length);
+                remainingAfter = remainingAfter.slice(marker.length);
+                foundMatch = true;
+                break; // Restart from beginning to handle nested formats correctly
+            }
+        }
+    }
+    return detected;
+}
+/**
+ * Apply formats to all text children of a LinkNode.
+ */
+function applyFormatsToLinkChildren(link, formats) {
+    for (const child of link.getChildren()) {
+        if ($isTextNode(child)) {
+            for (const format of formats) {
+                if (!child.hasFormat(format)) {
+                    child.toggleFormat(format);
+                }
+            }
+        }
+    }
+}
+/**
+ * Process a single LinkNode and its surrounding TextNodes.
+ * Returns true if any changes were made.
+ */
+function processLinkNode(linkNode) {
+    const prevSibling = linkNode.getPreviousSibling();
+    const nextSibling = linkNode.getNextSibling();
+    // We need TextNodes on both sides
+    if (!$isTextNode(prevSibling) || !$isTextNode(nextSibling)) {
+        return false;
+    }
+    const beforeText = prevSibling.getTextContent();
+    const afterText = nextSibling.getTextContent();
+    // Detect format markers
+    const detected = detectSurroundingFormats(beforeText, afterText);
+    if (detected.length === 0) {
+        return false;
+    }
+    // Calculate total marker lengths to remove
+    let totalBeforeLength = 0;
+    let totalAfterLength = 0;
+    const formats = [];
+    for (const { format, markerLength } of detected) {
+        formats.push(format);
+        totalBeforeLength += markerLength;
+        totalAfterLength += markerLength;
+    }
+    // Apply formats to link children
+    applyFormatsToLinkChildren(linkNode, formats);
+    // Remove markers from surrounding TextNodes
+    const newBeforeText = beforeText.slice(0, -totalBeforeLength);
+    const newAfterText = afterText.slice(totalAfterLength);
+    // Update or remove the before TextNode
+    if (newBeforeText.length === 0) {
+        prevSibling.remove();
+    }
+    else {
+        prevSibling.setTextContent(newBeforeText);
+    }
+    // Update or remove the after TextNode
+    if (newAfterText.length === 0) {
+        nextSibling.remove();
+    }
+    else {
+        nextSibling.setTextContent(newAfterText);
+    }
+    return true;
+}
+/**
+ * Find all LinkNodes in the editor tree.
+ */
+function findAllLinkNodes(root) {
+    const linkNodes = [];
+    const traverse = (node) => {
+        if ($isLinkNode(node)) {
+            linkNodes.push(node);
+        }
+        if ($isElementNode(node)) {
+            for (const child of node.getChildren()) {
+                traverse(child);
+            }
+        }
+    };
+    traverse(root);
+    return linkNodes;
+}
+/**
+ * WikiLinkFormatPlugin - Applies formatting to wiki links when surrounded by format markers
+ *
+ * This plugin detects patterns like `**[[page]]**` typed during live editing and:
+ * 1. Removes the format markers from the surrounding TextNodes
+ * 2. Applies the format (bold, italic, strikethrough) to the wiki link's text children
+ *
+ * Supports:
+ * - Bold: **[[page]]** or __[[page]]__
+ * - Italic: *[[page]]* or _[[page]]_
+ * - Strikethrough: ~~[[page]]~~
+ * - Nested: ***[[page]]*** (bold + italic)
+ *
+ * The plugin runs as a post-processing step after the markdown shortcuts transforms,
+ * using an update listener to detect and modify the tree.
+ */
+export function WikiLinkFormatPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        return editor.registerUpdateListener(({ editorState, dirtyElements, dirtyLeaves, tags }) => {
+            // Skip if this update was triggered by us to prevent infinite loops
+            if (tags.has('wiki-link-format')) {
+                return;
+            }
+            // Early exit if nothing changed in this update
+            if (dirtyElements.size === 0 && dirtyLeaves.size === 0) {
+                return;
+            }
+            // Check if there are any LinkNodes with adjacent format markers,
+            // and apply formatting in a single pass if found
+            let needsUpdate = false;
+            editorState.read(() => {
+                const root = $getRoot();
+                const linkNodes = findAllLinkNodes(root);
+                for (const linkNode of linkNodes) {
+                    const prevSibling = linkNode.getPreviousSibling();
+                    const nextSibling = linkNode.getNextSibling();
+                    if (!$isTextNode(prevSibling) || !$isTextNode(nextSibling)) {
+                        continue;
+                    }
+                    const beforeText = prevSibling.getTextContent();
+                    const afterText = nextSibling.getTextContent();
+                    const detected = detectSurroundingFormats(beforeText, afterText);
+                    if (detected.length > 0) {
+                        needsUpdate = true;
+                        break;
+                    }
+                }
+            });
+            if (!needsUpdate) {
+                return;
+            }
+            // Perform the update
+            editor.update(() => {
+                const root = $getRoot();
+                const linkNodes = findAllLinkNodes(root);
+                for (const linkNode of linkNodes) {
+                    processLinkNode(linkNode);
+                }
+            }, { tag: 'wiki-link-format' });
+        });
+    }, [editor]);
+    return null;
+}