@datalayer/lexical-loro 0.0.3 → 0.1.0

package/lib/plugins/ShortcutsPlugin/index.js

@@ -0,0 +1,112 @@
+import { TOGGLE_LINK_COMMAND } from '@lexical/link';
+import { COMMAND_PRIORITY_NORMAL, FORMAT_ELEMENT_COMMAND, FORMAT_TEXT_COMMAND, INDENT_CONTENT_COMMAND, isModifierMatch, KEY_DOWN_COMMAND, OUTDENT_CONTENT_COMMAND, } from 'lexical';
+import { useEffect } from 'react';
+import { useToolbarState } from '../../context/ToolbarContext';
+import { sanitizeUrl } from '../../utils/url';
+import { INSERT_INLINE_COMMAND } from '../CommentPlugin';
+import { clearFormatting, formatBulletList, formatCheckList, formatCode, formatHeading, formatNumberedList, formatParagraph, formatQuote, updateFontSize, UpdateFontSizeType, } from '../ToolbarPlugin/utils';
+import { isAddComment, isCapitalize, isCenterAlign, isClearFormatting, isDecreaseFontSize, isFormatBulletList, isFormatCheckList, isFormatCode, isFormatHeading, isFormatNumberedList, isFormatParagraph, isFormatQuote, isIncreaseFontSize, isIndent, isInsertCodeBlock, isInsertLink, isJustifyAlign, isLeftAlign, isLowercase, isOutdent, isRightAlign, isStrikeThrough, isSubscript, isSuperscript, isUppercase, } from './shortcuts';
+export default function ShortcutsPlugin({ editor, setIsLinkEditMode, }) {
+    const { toolbarState } = useToolbarState();
+    useEffect(() => {
+        const keyboardShortcutsHandler = (event) => {
+            // Short-circuit, a least one modifier must be set
+            if (isModifierMatch(event, {})) {
+                return false;
+            }
+            else if (isFormatParagraph(event)) {
+                formatParagraph(editor);
+            }
+            else if (isFormatHeading(event)) {
+                const { code } = event;
+                const headingSize = `h${code[code.length - 1]}`;
+                formatHeading(editor, toolbarState.blockType, headingSize);
+            }
+            else if (isFormatBulletList(event)) {
+                formatBulletList(editor, toolbarState.blockType);
+            }
+            else if (isFormatNumberedList(event)) {
+                formatNumberedList(editor, toolbarState.blockType);
+            }
+            else if (isFormatCheckList(event)) {
+                formatCheckList(editor, toolbarState.blockType);
+            }
+            else if (isFormatCode(event)) {
+                formatCode(editor, toolbarState.blockType);
+            }
+            else if (isFormatQuote(event)) {
+                formatQuote(editor, toolbarState.blockType);
+            }
+            else if (isStrikeThrough(event)) {
+                editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'strikethrough');
+            }
+            else if (isLowercase(event)) {
+                editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'lowercase');
+            }
+            else if (isUppercase(event)) {
+                editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'uppercase');
+            }
+            else if (isCapitalize(event)) {
+                editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'capitalize');
+            }
+            else if (isIndent(event)) {
+                editor.dispatchCommand(INDENT_CONTENT_COMMAND, undefined);
+            }
+            else if (isOutdent(event)) {
+                editor.dispatchCommand(OUTDENT_CONTENT_COMMAND, undefined);
+            }
+            else if (isCenterAlign(event)) {
+                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'center');
+            }
+            else if (isLeftAlign(event)) {
+                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'left');
+            }
+            else if (isRightAlign(event)) {
+                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'right');
+            }
+            else if (isJustifyAlign(event)) {
+                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'justify');
+            }
+            else if (isSubscript(event)) {
+                editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'subscript');
+            }
+            else if (isSuperscript(event)) {
+                editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'superscript');
+            }
+            else if (isInsertCodeBlock(event)) {
+                editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'code');
+            }
+            else if (isIncreaseFontSize(event)) {
+                updateFontSize(editor, UpdateFontSizeType.increment, toolbarState.fontSizeInputValue);
+            }
+            else if (isDecreaseFontSize(event)) {
+                updateFontSize(editor, UpdateFontSizeType.decrement, toolbarState.fontSizeInputValue);
+            }
+            else if (isClearFormatting(event)) {
+                clearFormatting(editor);
+            }
+            else if (isInsertLink(event)) {
+                const url = toolbarState.isLink ? null : sanitizeUrl('https://');
+                setIsLinkEditMode(!toolbarState.isLink);
+                editor.dispatchCommand(TOGGLE_LINK_COMMAND, url);
+            }
+            else if (isAddComment(event)) {
+                editor.dispatchCommand(INSERT_INLINE_COMMAND, undefined);
+            }
+            else {
+                // No match for any of the event handlers
+                return false;
+            }
+            event.preventDefault();
+            return true;
+        };
+        return editor.registerCommand(KEY_DOWN_COMMAND, keyboardShortcutsHandler, COMMAND_PRIORITY_NORMAL);
+    }, [
+        editor,
+        toolbarState.isLink,
+        toolbarState.blockType,
+        toolbarState.fontSizeInputValue,
+        setIsLinkEditMode,
+    ]);
+    return null;
+}

package/lib/plugins/ShortcutsPlugin/shortcuts.d.ts

@@ -0,0 +1,59 @@
+export declare const SHORTCUTS: Readonly<{
+    NORMAL: "⌘+Opt+0" | "Ctrl+Alt+0";
+    HEADING1: "⌘+Opt+1" | "Ctrl+Alt+1";
+    HEADING2: "⌘+Opt+2" | "Ctrl+Alt+2";
+    HEADING3: "⌘+Opt+3" | "Ctrl+Alt+3";
+    NUMBERED_LIST: "⌘+Shift+7" | "Ctrl+Shift+7";
+    BULLET_LIST: "⌘+Shift+8" | "Ctrl+Shift+8";
+    CHECK_LIST: "⌘+Shift+9" | "Ctrl+Shift+9";
+    CODE_BLOCK: "⌘+Opt+C" | "Ctrl+Alt+C";
+    QUOTE: "⌃+Shift+Q" | "Ctrl+Shift+Q";
+    ADD_COMMENT: "⌘+Opt+M" | "Ctrl+Alt+M";
+    INCREASE_FONT_SIZE: "⌘+Shift+." | "Ctrl+Shift+.";
+    DECREASE_FONT_SIZE: "⌘+Shift+," | "Ctrl+Shift+,";
+    INSERT_CODE_BLOCK: "⌘+Shift+C" | "Ctrl+Shift+C";
+    STRIKETHROUGH: "⌘+Shift+X" | "Ctrl+Shift+X";
+    LOWERCASE: "⌃+Shift+1" | "Ctrl+Shift+1";
+    UPPERCASE: "⌃+Shift+2" | "Ctrl+Shift+2";
+    CAPITALIZE: "⌃+Shift+3" | "Ctrl+Shift+3";
+    CENTER_ALIGN: "⌘+Shift+E" | "Ctrl+Shift+E";
+    JUSTIFY_ALIGN: "⌘+Shift+J" | "Ctrl+Shift+J";
+    LEFT_ALIGN: "⌘+Shift+L" | "Ctrl+Shift+L";
+    RIGHT_ALIGN: "⌘+Shift+R" | "Ctrl+Shift+R";
+    SUBSCRIPT: "⌘+," | "Ctrl+,";
+    SUPERSCRIPT: "⌘+." | "Ctrl+.";
+    INDENT: "⌘+]" | "Ctrl+]";
+    OUTDENT: "⌘+[" | "Ctrl+[";
+    CLEAR_FORMATTING: "⌘+\\" | "Ctrl+\\";
+    REDO: "⌘+Shift+Z" | "Ctrl+Y";
+    UNDO: "⌘+Z" | "Ctrl+Z";
+    BOLD: "⌘+B" | "Ctrl+B";
+    ITALIC: "⌘+I" | "Ctrl+I";
+    UNDERLINE: "⌘+U" | "Ctrl+U";
+    INSERT_LINK: "⌘+K" | "Ctrl+K";
+}>;
+export declare function isFormatParagraph(event: KeyboardEvent): boolean;
+export declare function isFormatHeading(event: KeyboardEvent): boolean;
+export declare function isFormatNumberedList(event: KeyboardEvent): boolean;
+export declare function isFormatBulletList(event: KeyboardEvent): boolean;
+export declare function isFormatCheckList(event: KeyboardEvent): boolean;
+export declare function isFormatCode(event: KeyboardEvent): boolean;
+export declare function isFormatQuote(event: KeyboardEvent): boolean;
+export declare function isLowercase(event: KeyboardEvent): boolean;
+export declare function isUppercase(event: KeyboardEvent): boolean;
+export declare function isCapitalize(event: KeyboardEvent): boolean;
+export declare function isStrikeThrough(event: KeyboardEvent): boolean;
+export declare function isIndent(event: KeyboardEvent): boolean;
+export declare function isOutdent(event: KeyboardEvent): boolean;
+export declare function isCenterAlign(event: KeyboardEvent): boolean;
+export declare function isLeftAlign(event: KeyboardEvent): boolean;
+export declare function isRightAlign(event: KeyboardEvent): boolean;
+export declare function isJustifyAlign(event: KeyboardEvent): boolean;
+export declare function isSubscript(event: KeyboardEvent): boolean;
+export declare function isSuperscript(event: KeyboardEvent): boolean;
+export declare function isInsertCodeBlock(event: KeyboardEvent): boolean;
+export declare function isIncreaseFontSize(event: KeyboardEvent): boolean;
+export declare function isDecreaseFontSize(event: KeyboardEvent): boolean;
+export declare function isClearFormatting(event: KeyboardEvent): boolean;
+export declare function isInsertLink(event: KeyboardEvent): boolean;
+export declare function isAddComment(event: KeyboardEvent): boolean;

package/lib/plugins/ShortcutsPlugin/shortcuts.js

@@ -0,0 +1,169 @@
+import { IS_APPLE } from '@lexical/utils';
+import { isModifierMatch } from 'lexical';
+//disable eslint sorting rule for quick reference to shortcuts
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+export const SHORTCUTS = Object.freeze({
+    // (Ctrl|⌘) + (Alt|Option) + <key> shortcuts
+    NORMAL: IS_APPLE ? '⌘+Opt+0' : 'Ctrl+Alt+0',
+    HEADING1: IS_APPLE ? '⌘+Opt+1' : 'Ctrl+Alt+1',
+    HEADING2: IS_APPLE ? '⌘+Opt+2' : 'Ctrl+Alt+2',
+    HEADING3: IS_APPLE ? '⌘+Opt+3' : 'Ctrl+Alt+3',
+    NUMBERED_LIST: IS_APPLE ? '⌘+Shift+7' : 'Ctrl+Shift+7',
+    BULLET_LIST: IS_APPLE ? '⌘+Shift+8' : 'Ctrl+Shift+8',
+    CHECK_LIST: IS_APPLE ? '⌘+Shift+9' : 'Ctrl+Shift+9',
+    CODE_BLOCK: IS_APPLE ? '⌘+Opt+C' : 'Ctrl+Alt+C',
+    QUOTE: IS_APPLE ? '⌃+Shift+Q' : 'Ctrl+Shift+Q',
+    ADD_COMMENT: IS_APPLE ? '⌘+Opt+M' : 'Ctrl+Alt+M',
+    // (Ctrl|⌘) + Shift + <key> shortcuts
+    INCREASE_FONT_SIZE: IS_APPLE ? '⌘+Shift+.' : 'Ctrl+Shift+.',
+    DECREASE_FONT_SIZE: IS_APPLE ? '⌘+Shift+,' : 'Ctrl+Shift+,',
+    INSERT_CODE_BLOCK: IS_APPLE ? '⌘+Shift+C' : 'Ctrl+Shift+C',
+    STRIKETHROUGH: IS_APPLE ? '⌘+Shift+X' : 'Ctrl+Shift+X',
+    LOWERCASE: IS_APPLE ? '⌃+Shift+1' : 'Ctrl+Shift+1',
+    UPPERCASE: IS_APPLE ? '⌃+Shift+2' : 'Ctrl+Shift+2',
+    CAPITALIZE: IS_APPLE ? '⌃+Shift+3' : 'Ctrl+Shift+3',
+    CENTER_ALIGN: IS_APPLE ? '⌘+Shift+E' : 'Ctrl+Shift+E',
+    JUSTIFY_ALIGN: IS_APPLE ? '⌘+Shift+J' : 'Ctrl+Shift+J',
+    LEFT_ALIGN: IS_APPLE ? '⌘+Shift+L' : 'Ctrl+Shift+L',
+    RIGHT_ALIGN: IS_APPLE ? '⌘+Shift+R' : 'Ctrl+Shift+R',
+    // (Ctrl|⌘) + <key> shortcuts
+    SUBSCRIPT: IS_APPLE ? '⌘+,' : 'Ctrl+,',
+    SUPERSCRIPT: IS_APPLE ? '⌘+.' : 'Ctrl+.',
+    INDENT: IS_APPLE ? '⌘+]' : 'Ctrl+]',
+    OUTDENT: IS_APPLE ? '⌘+[' : 'Ctrl+[',
+    CLEAR_FORMATTING: IS_APPLE ? '⌘+\\' : 'Ctrl+\\',
+    REDO: IS_APPLE ? '⌘+Shift+Z' : 'Ctrl+Y',
+    UNDO: IS_APPLE ? '⌘+Z' : 'Ctrl+Z',
+    BOLD: IS_APPLE ? '⌘+B' : 'Ctrl+B',
+    ITALIC: IS_APPLE ? '⌘+I' : 'Ctrl+I',
+    UNDERLINE: IS_APPLE ? '⌘+U' : 'Ctrl+U',
+    INSERT_LINK: IS_APPLE ? '⌘+K' : 'Ctrl+K',
+});
+const CONTROL_OR_META = { ctrlKey: !IS_APPLE, metaKey: IS_APPLE };
+export function isFormatParagraph(event) {
+    const { code } = event;
+    return ((code === 'Numpad0' || code === 'Digit0') &&
+        isModifierMatch(event, { ...CONTROL_OR_META, altKey: true }));
+}
+export function isFormatHeading(event) {
+    const { code } = event;
+    // Apple pencil keyboard events don't have a code property
+    if (!code) {
+        return false;
+    }
+    const keyNumber = code[code.length - 1];
+    return (['1', '2', '3'].includes(keyNumber) &&
+        isModifierMatch(event, { ...CONTROL_OR_META, altKey: true }));
+}
+export function isFormatNumberedList(event) {
+    const { code } = event;
+    return ((code === 'Numpad7' || code === 'Digit7') &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isFormatBulletList(event) {
+    const { code } = event;
+    return ((code === 'Numpad8' || code === 'Digit8') &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isFormatCheckList(event) {
+    const { code } = event;
+    return ((code === 'Numpad9' || code === 'Digit9') &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isFormatCode(event) {
+    const { code } = event;
+    return (code === 'KeyC' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, altKey: true }));
+}
+export function isFormatQuote(event) {
+    const { code } = event;
+    return (code === 'KeyQ' &&
+        isModifierMatch(event, {
+            ctrlKey: true,
+            shiftKey: true,
+        }));
+}
+export function isLowercase(event) {
+    const { code } = event;
+    return ((code === 'Numpad1' || code === 'Digit1') &&
+        isModifierMatch(event, { ctrlKey: true, shiftKey: true }));
+}
+export function isUppercase(event) {
+    const { code } = event;
+    return ((code === 'Numpad2' || code === 'Digit2') &&
+        isModifierMatch(event, { ctrlKey: true, shiftKey: true }));
+}
+export function isCapitalize(event) {
+    const { code } = event;
+    return ((code === 'Numpad3' || code === 'Digit3') &&
+        isModifierMatch(event, { ctrlKey: true, shiftKey: true }));
+}
+export function isStrikeThrough(event) {
+    const { code } = event;
+    return (code === 'KeyX' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isIndent(event) {
+    const { code } = event;
+    return code === 'BracketRight' && isModifierMatch(event, CONTROL_OR_META);
+}
+export function isOutdent(event) {
+    const { code } = event;
+    return code === 'BracketLeft' && isModifierMatch(event, CONTROL_OR_META);
+}
+export function isCenterAlign(event) {
+    const { code } = event;
+    return (code === 'KeyE' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isLeftAlign(event) {
+    const { code } = event;
+    return (code === 'KeyL' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isRightAlign(event) {
+    const { code } = event;
+    return (code === 'KeyR' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isJustifyAlign(event) {
+    const { code } = event;
+    return (code === 'KeyJ' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isSubscript(event) {
+    const { code } = event;
+    return code === 'Comma' && isModifierMatch(event, CONTROL_OR_META);
+}
+export function isSuperscript(event) {
+    const { code } = event;
+    return code === 'Period' && isModifierMatch(event, CONTROL_OR_META);
+}
+export function isInsertCodeBlock(event) {
+    const { code } = event;
+    return (code === 'KeyC' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isIncreaseFontSize(event) {
+    const { code } = event;
+    return (code === 'Period' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isDecreaseFontSize(event) {
+    const { code } = event;
+    return (code === 'Comma' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, shiftKey: true }));
+}
+export function isClearFormatting(event) {
+    const { code } = event;
+    return code === 'Backslash' && isModifierMatch(event, CONTROL_OR_META);
+}
+export function isInsertLink(event) {
+    const { code } = event;
+    return code === 'KeyK' && isModifierMatch(event, CONTROL_OR_META);
+}
+export function isAddComment(event) {
+    const { code } = event;
+    return (code === 'KeyM' &&
+        isModifierMatch(event, { ...CONTROL_OR_META, altKey: true }));
+}

package/lib/plugins/SpecialTextPlugin/index.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from 'react';
+export default function SpecialTextPlugin(): JSX.Element | null;

package/lib/plugins/SpecialTextPlugin/index.js

@@ -0,0 +1,46 @@
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { TextNode } from 'lexical';
+import { useEffect } from 'react';
+import { $createSpecialTextNode, SpecialTextNode, } from '../../nodes/SpecialTextNode';
+const BRACKETED_TEXT_REGEX = /\[([^\[\]]+)\]/; // eslint-disable-line
+function $findAndTransformText(node) {
+    const text = node.getTextContent();
+    const match = BRACKETED_TEXT_REGEX.exec(text);
+    if (match) {
+        const matchedText = match[1];
+        const startIndex = match.index;
+        let targetNode;
+        if (startIndex === 0) {
+            [targetNode] = node.splitText(startIndex + match[0].length);
+        }
+        else {
+            [, targetNode] = node.splitText(startIndex, startIndex + match[0].length);
+        }
+        const specialTextNode = $createSpecialTextNode(matchedText);
+        targetNode.replace(specialTextNode);
+        return specialTextNode;
+    }
+    return null;
+}
+function $textNodeTransform(node) {
+    let targetNode = node;
+    while (targetNode !== null) {
+        if (!targetNode.isSimpleText()) {
+            return;
+        }
+        targetNode = $findAndTransformText(targetNode);
+    }
+}
+function useTextTransformation(editor) {
+    useEffect(() => {
+        if (!editor.hasNodes([SpecialTextNode])) {
+            throw new Error('SpecialTextPlugin: SpecialTextNode not registered on editor');
+        }
+        return editor.registerNodeTransform(TextNode, $textNodeTransform);
+    }, [editor]);
+}
+export default function SpecialTextPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useTextTransformation(editor);
+    return null;
+}

package/lib/plugins/SpeechToTextPlugin/index.d.ts

@@ -0,0 +1,5 @@
+import type { LexicalCommand } from 'lexical';
+export declare const SPEECH_TO_TEXT_COMMAND: LexicalCommand<boolean>;
+export declare const SUPPORT_SPEECH_RECOGNITION: boolean;
+declare const _default: () => null;
+export default _default;

package/lib/plugins/SpeechToTextPlugin/index.js

@@ -0,0 +1,82 @@
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand, REDO_COMMAND, UNDO_COMMAND, } from 'lexical';
+import { useEffect, useRef, useState } from 'react';
+import useReport from '../../hooks/useReport';
+export const SPEECH_TO_TEXT_COMMAND = createCommand('SPEECH_TO_TEXT_COMMAND');
+const VOICE_COMMANDS = {
+    '\n': ({ selection }) => {
+        selection.insertParagraph();
+    },
+    redo: ({ editor }) => {
+        editor.dispatchCommand(REDO_COMMAND, undefined);
+    },
+    undo: ({ editor }) => {
+        editor.dispatchCommand(UNDO_COMMAND, undefined);
+    },
+};
+export const SUPPORT_SPEECH_RECOGNITION = 'SpeechRecognition' in window || 'webkitSpeechRecognition' in window;
+function SpeechToTextPlugin() {
+    const [editor] = useLexicalComposerContext();
+    const [isEnabled, setIsEnabled] = useState(false);
+    const SpeechRecognition = 
+    // @ts-expect-error missing type
+    window.SpeechRecognition || window.webkitSpeechRecognition;
+    const recognition = useRef(null);
+    const report = useReport();
+    useEffect(() => {
+        if (isEnabled && recognition.current === null) {
+            recognition.current = new SpeechRecognition();
+            recognition.current.continuous = true;
+            recognition.current.interimResults = true;
+            recognition.current.addEventListener('result', (event) => {
+                const resultItem = event.results.item(event.resultIndex);
+                const { transcript } = resultItem.item(0);
+                report(transcript);
+                if (!resultItem.isFinal) {
+                    return;
+                }
+                editor.update(() => {
+                    const selection = $getSelection();
+                    if ($isRangeSelection(selection)) {
+                        const command = VOICE_COMMANDS[transcript.toLowerCase().trim()];
+                        if (command) {
+                            command({
+                                editor,
+                                selection,
+                            });
+                        }
+                        else if (transcript.match(/\s*\n\s*/)) {
+                            selection.insertParagraph();
+                        }
+                        else {
+                            selection.insertText(transcript);
+                        }
+                    }
+                });
+            });
+        }
+        if (recognition.current) {
+            if (isEnabled) {
+                recognition.current.start();
+            }
+            else {
+                recognition.current.stop();
+            }
+        }
+        return () => {
+            if (recognition.current !== null) {
+                recognition.current.stop();
+            }
+        };
+    }, [SpeechRecognition, editor, isEnabled, report]);
+    useEffect(() => {
+        return editor.registerCommand(SPEECH_TO_TEXT_COMMAND, (_isEnabled) => {
+            setIsEnabled(_isEnabled);
+            return true;
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [editor]);
+    return null;
+}
+export default (SUPPORT_SPEECH_RECOGNITION
+    ? SpeechToTextPlugin
+    : () => null);

package/lib/plugins/StickyPlugin/index.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from 'react';
+export default function StickyPlugin(): JSX.Element | null;

package/lib/plugins/StickyPlugin/index.js

@@ -0,0 +1,12 @@
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useEffect } from 'react';
+import { StickyNode } from '../../nodes/StickyNode';
+export default function StickyPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        if (!editor.hasNodes([StickyNode])) {
+            throw new Error('StickyPlugin: StickyNode not registered on editor');
+        }
+    }, [editor]);
+    return null;
+}

package/lib/plugins/TabFocusPlugin/index.d.ts

@@ -0,0 +1 @@
+export default function TabFocusPlugin(): null;

package/lib/plugins/TabFocusPlugin/index.js

@@ -0,0 +1,34 @@
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getSelection, $isRangeSelection, $setSelection, COMMAND_PRIORITY_LOW, FOCUS_COMMAND, } from 'lexical';
+import { useEffect } from 'react';
+const TAB_TO_FOCUS_INTERVAL = 100;
+let lastTabKeyDownTimestamp = 0;
+let hasRegisteredKeyDownListener = false;
+function registerKeyTimeStampTracker() {
+    window.addEventListener('keydown', (event) => {
+        // Tab
+        if (event.key === 'Tab') {
+            lastTabKeyDownTimestamp = event.timeStamp;
+        }
+    }, true);
+}
+export default function TabFocusPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        if (!hasRegisteredKeyDownListener) {
+            registerKeyTimeStampTracker();
+            hasRegisteredKeyDownListener = true;
+        }
+        return editor.registerCommand(FOCUS_COMMAND, (event) => {
+            const selection = $getSelection();
+            if ($isRangeSelection(selection)) {
+                if (lastTabKeyDownTimestamp + TAB_TO_FOCUS_INTERVAL >
+                    event.timeStamp) {
+                    $setSelection(selection.clone());
+                }
+            }
+            return false;
+        }, COMMAND_PRIORITY_LOW);
+    }, [editor]);
+    return null;
+}

package/lib/plugins/TableActionMenuPlugin/index.d.ts

@@ -0,0 +1,5 @@
+import { ReactPortal } from 'react';
+export default function TableActionMenuPlugin({ anchorElem, cellMerge, }: {
+    anchorElem?: HTMLElement;
+    cellMerge?: boolean;
+}): null | ReactPortal;