@blocklet/editor-lite 2.6.0

package/lib/ext/PostLinkEmbedPlugin/PostLinkNode.js

@@ -0,0 +1,140 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DecoratorNode } from 'lexical';
+import { Suspense } from 'react';
+import { joinURL, withFragment } from 'ufo';
+import Box from '@mui/material/Box';
+import { useTheme } from '@mui/material';
+import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
+import { exhaustiveGuard, safeParseJSON, discussKitMountPoint } from '../utils';
+function PostLinkComponent(postInfo) {
+    const { locale } = useLocaleContext();
+    const { palette } = useTheme();
+    // PostLinkNode 新/旧版本对于 link 的处理:
+    // - 旧版本: 存储 post link, 渲染 link 时直接使用 post link
+    // - 新版本: 连同 id, type, boardId 等信息一并存储, 渲染 link 时动态拼接 post link (与 embed 时的 post link 解耦)
+    let { link } = postInfo;
+    // pageGroup 模式下 path 需要特殊处理
+    const { pageGroup } = window.blocklet;
+    // 存在 type, 说明是新版本, 拼接 post link
+    if (postInfo.type && !postInfo.external) {
+        switch (postInfo.type) {
+            case 'post':
+                link =
+                    pageGroup === 'discussion'
+                        ? joinURL(window.blocklet.prefix, postInfo.id)
+                        : joinURL(discussKitMountPoint, '/discussions', postInfo.id);
+                break;
+            case 'blog':
+                link =
+                    pageGroup === 'blog'
+                        ? joinURL(window.blocklet.prefix, locale, postInfo.id)
+                        : joinURL(discussKitMountPoint, '/blog', locale, postInfo.id);
+                break;
+            case 'doc':
+                link =
+                    pageGroup === 'doc'
+                        ? joinURL(window.blocklet.prefix, postInfo.boardId, locale, postInfo.id)
+                        : joinURL(discussKitMountPoint, '/docs', postInfo.boardId, locale, postInfo.id);
+                break;
+            case 'task':
+                break;
+            default:
+                exhaustiveGuard(postInfo.type);
+        }
+        try {
+            link = withFragment(link, new URL(postInfo.link).hash.slice(1));
+        }
+        catch {
+            // ignore
+        }
+    }
+    return (_jsxs(Box, { sx: {
+            display: 'flex',
+            alignItems: 'center',
+            '&:hover': { bgcolor: 'grey.200', boxShadow: `0 0 0 3px ${palette.grey[200]}`, borderRadius: 1 },
+        }, children: [_jsx(Box, { component: "i", className: "iconify", "data-icon": postInfo.type === 'task' ? 'lucide:list-todo' : 'ri:file-list-2-line', sx: { flex: '0 0 auto', width: 18, height: 18, mr: 0.25, color: 'grey.600' } }), _jsx(Box, { component: "a", href: link, sx: {
+                    display: 'inline-block',
+                    overflow: 'hidden',
+                    textOverflow: 'ellipsis',
+                    whiteSpace: 'nowrap',
+                    wordBreak: 'break-word',
+                    height: 18,
+                    lineHeight: '18px',
+                    borderBottom: '1px solid',
+                    borderColor: 'divider',
+                    fontSize: 14,
+                    textDecoration: 'none',
+                    fontWeight: 'medium',
+                    color: 'inherit',
+                }, title: postInfo.title ?? link, children: postInfo.title ?? link }), !!postInfo.external && (_jsx(Box, { component: "i", className: "iconify", "data-icon": "majesticons:external-link-line", sx: { flex: '0 0 auto', width: 16, height: 16, ml: 0.5, color: 'grey.600' } }))] }));
+}
+function convertPostElement(domNode) {
+    if (domNode instanceof HTMLElement && domNode.getAttribute('data-lexical-post-link-json')) {
+        const postInfo = domNode.getAttribute('data-lexical-post-link-json');
+        const node = $createPostLinkNode(safeParseJSON(postInfo, {}));
+        return { node };
+    }
+    return null;
+}
+export class PostLinkNode extends DecoratorNode {
+    __postInfo;
+    static getType() {
+        return 'post-link';
+    }
+    static clone(node) {
+        return new PostLinkNode({ ...node.__postInfo }, node.__key);
+    }
+    static importJSON(serializedNode) {
+        const { postInfo } = serializedNode;
+        const node = $createPostLinkNode(safeParseJSON(postInfo, {}));
+        return node;
+    }
+    exportDOM() {
+        const element = document.createElement('a');
+        element.setAttribute('href', this.__postInfo.link || '');
+        element.setAttribute('data-lexical-post-link-json', JSON.stringify(this.__postInfo));
+        const text = document.createTextNode(this.__postInfo.title ?? this.__postInfo.link);
+        element.appendChild(text);
+        return { element };
+    }
+    static importDOM() {
+        return {
+            img: (node) => ({
+                conversion: convertPostElement,
+                priority: 0,
+            }),
+        };
+    }
+    constructor(postInfo, key) {
+        super(key);
+        this.__postInfo = postInfo;
+    }
+    exportJSON() {
+        return {
+            postInfo: JSON.stringify(this.__postInfo),
+            type: 'post-link',
+            version: 1,
+        };
+    }
+    // View
+    createDOM(config) {
+        const span = document.createElement('span');
+        span.className = 'inline-embed-container';
+        return span;
+    }
+    updateDOM() {
+        return false;
+    }
+    getPostInfo() {
+        return this.__postInfo;
+    }
+    decorate() {
+        return (_jsx(Suspense, { fallback: null, children: _jsx(PostLinkComponent, { ...this.__postInfo }) }));
+    }
+}
+export function $createPostLinkNode(postInfo) {
+    return new PostLinkNode(postInfo);
+}
+export function $isPostLinkNode(node) {
+    return node instanceof PostLinkNode;
+}

package/lib/ext/PostLinkEmbedPlugin/fixInvalidPostLinkNodes.d.ts

@@ -0,0 +1 @@
+export declare function useFixInvalidPostLinkNodes(): void;

package/lib/ext/PostLinkEmbedPlugin/fixInvalidPostLinkNodes.js

@@ -0,0 +1,15 @@
+import { useEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { PostLinkNode } from './PostLinkNode';
+// 移除 postInfo 为空的无效 PostLinkNode (可能是复制粘贴产生的)
+export function useFixInvalidPostLinkNodes() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        function transform(node) {
+            if (!node.getPostInfo()) {
+                node.remove();
+            }
+        }
+        return editor.registerNodeTransform(PostLinkNode, transform);
+    }, [editor]);
+}

package/lib/ext/PostLinkEmbedPlugin/index.d.ts

@@ -0,0 +1,21 @@
+import { LexicalCommand, LexicalEditor } from 'lexical';
+import { type JSX } from 'react';
+import { AutoEmbedOption } from '@lexical/react/LexicalAutoEmbedPlugin';
+import { EditorConfig } from '../../config';
+type PostType = 'post' | 'blog' | 'doc' | 'task';
+type Payload = {
+    id: string;
+    type: PostType;
+    url: string;
+    title: string;
+    boardId: string;
+    external?: boolean;
+};
+export declare const INSERT_POST_LINK_COMMAND: LexicalCommand<Payload>;
+/**
+ * 创建 "Embed Post Link" AutoEmbedOption
+ * 未挂载 discuss kit 或 url 不匹配 discussion/blog/doc 详情页 => 不显示 "Embed Post Link" option
+ */
+export declare const createPostLinkAutoEmbedOption: (editor: LexicalEditor, editorConfig: EditorConfig) => AutoEmbedOption | null;
+export default function PostLinkEmbedPlugin(): JSX.Element | null;
+export {};

package/lib/ext/PostLinkEmbedPlugin/index.js

@@ -0,0 +1,148 @@
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $createTextNode, $insertNodes, COMMAND_PRIORITY_EDITOR, createCommand, } from 'lexical';
+import { useEffect } from 'react';
+import { AutoEmbedOption } from '@lexical/react/LexicalAutoEmbedPlugin';
+import { $createLinkNode } from '@lexical/link';
+import { Path } from 'path-parser';
+import { joinURL } from 'ufo';
+import { $createPostLinkNode, PostLinkNode } from './PostLinkNode';
+import { $createEmojiNode } from '../../main/nodes/EmojiNode';
+import { $getLinkNode, getBlockletMountPointInfo, isSameHost } from '../utils';
+const taskMountPoint = window.blocklet.componentMountPoints?.find((x) => x.did === 'z2qa4xMVAJxvA1GgfnPpMFqhdSjU9pe37NCiY')?.mountPoint;
+const paths = [
+    { path: '/discussions/:id', type: 'post' },
+    { path: '/blog/:locale/:id', type: 'blog' },
+    {
+        path: '/blog/:locale/post/:year/:month/:date/:id',
+        type: 'blog',
+        getId: (match) => `${match.year}-${match.month}-${match.date}-${match.id}`,
+    },
+    { path: '/docs/:board/:locale/:id', type: 'doc' },
+];
+if (taskMountPoint) {
+    paths.push({ path: joinURL(taskMountPoint, '/task/:id'), type: 'task' });
+}
+const discussKitMountPoint = getBlockletMountPointInfo('did-comments')?.mountPoint;
+const fetchPostInfo = async ({ id, url, type, }) => {
+    try {
+        const urlObj = new URL(url);
+        if (type === 'task' && taskMountPoint) {
+            const taskRes = await fetch(joinURL(urlObj.origin, taskMountPoint, `/api/task/item/${id}`)).then((res) => res.json());
+            if (taskRes.data.task) {
+                return { id, title: taskRes.data.task.title, boardId: '', external: true };
+            }
+        }
+        if (isSameHost(urlObj)) {
+            const res = await fetch(joinURL(discussKitMountPoint, `/api/embed/posts/slug/${id}`));
+            return await res.json();
+        }
+        const blockletJs = joinURL(urlObj.origin, '/__blocklet__.js?type=json');
+        const blockletInfo = await fetch(blockletJs).then((res) => res.json());
+        const mountPoint = blockletInfo?.componentMountPoints?.find((x) => x.name === 'did-comments')?.mountPoint;
+        if (mountPoint) {
+            const postInfo = await fetch(joinURL(urlObj.origin, mountPoint, `/api/embed/posts/slug/${id}`)).then((res) => res.json());
+            return { ...postInfo, external: true };
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+};
+const parsePostLink = (url) => {
+    try {
+        const urlObj = new URL(url);
+        // 无论 host 是否相同, 都尝试与 paths 匹配
+        for (const { path, type, getId } of paths) {
+            const match = new Path(path).test(urlObj.pathname) || new Path(`/:prefix${path}`).test(urlObj.pathname);
+            if (match) {
+                return {
+                    id: getId ? getId(match) : match.id,
+                    type,
+                    url,
+                };
+            }
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return null;
+};
+export const INSERT_POST_LINK_COMMAND = createCommand('INSERT_POST_LINK_COMMAND');
+/**
+ * 创建 "Embed Post Link" AutoEmbedOption
+ * 未挂载 discuss kit 或 url 不匹配 discussion/blog/doc 详情页 => 不显示 "Embed Post Link" option
+ */
+export const createPostLinkAutoEmbedOption = (editor, editorConfig) => {
+    const linkNode = $getLinkNode(editor);
+    const url = linkNode?.__url;
+    if (editorConfig.openGraphEndpoint && url) {
+        const parsed = parsePostLink(url);
+        if (!parsed) {
+            return null;
+        }
+        return new AutoEmbedOption('Embed Post Link', {
+            onSelect: () => {
+                editor.update(async () => {
+                    linkNode.selectEnd();
+                    linkNode.remove();
+                    const whitespace = $createTextNode(' ');
+                    const loadingNode = $createEmojiNode('global-loading', '');
+                    $insertNodes([loadingNode, whitespace]);
+                    try {
+                        const postInfo = await fetchPostInfo(parsed);
+                        if (!postInfo) {
+                            throw new Error('PostLinkEmbedPlugin: postInfo not found');
+                        }
+                        editor.update(() => {
+                            loadingNode.remove();
+                            editor.dispatchCommand(INSERT_POST_LINK_COMMAND, { ...postInfo, type: parsed.type, url });
+                        });
+                    }
+                    catch (e) {
+                        if (e instanceof Error) {
+                            console.error('PostLinkEmbedPlugin: ', e.message);
+                        }
+                        editor.update(() => {
+                            loadingNode.remove();
+                            // 获取 postInfo 失败, 恢复显示 link
+                            $insertNodes([
+                                $createLinkNode(linkNode.__url).append($createTextNode(linkNode.__url)),
+                                $createTextNode(' '),
+                            ]);
+                        });
+                    }
+                });
+            },
+        });
+    }
+    return null;
+};
+export default function PostLinkEmbedPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        if (!editor.hasNodes([PostLinkNode])) {
+            throw new Error('PostLinkEmbedPlugin: PostLinkNode not registered on editor');
+        }
+        return editor.registerCommand(INSERT_POST_LINK_COMMAND, (payload) => {
+            editor.update(() => {
+                if (payload) {
+                    const postLinkNode = $createPostLinkNode({
+                        id: payload.id,
+                        title: payload.title,
+                        link: payload.url || '',
+                        type: payload.type,
+                        boardId: payload.boardId,
+                        external: payload.external,
+                    });
+                    $insertNodes([postLinkNode, $createTextNode(' ')]);
+                    // 删除前面的空格 (与 loadingNode 一起插入的空格)
+                    postLinkNode.getPreviousSibling()?.remove();
+                }
+            });
+            return true;
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [editor]);
+    return null;
+}

package/lib/ext/RemoveListPlugin.d.ts

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

package/lib/ext/RemoveListPlugin.js

@@ -0,0 +1,63 @@
+import { $isListItemNode, $isListNode, ListItemNode } from '@lexical/list';
+import { mergeRegister, $getNearestNodeOfType } from '@lexical/utils';
+import { COMMAND_PRIORITY_CRITICAL, KEY_DOWN_COMMAND, $getSelection, $isRangeSelection, $createParagraphNode, } from 'lexical';
+import { useEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+function $isLastItemInList(listItem) {
+    let isLast = true;
+    const firstChild = listItem.getFirstChild();
+    if ($isListNode(firstChild)) {
+        return false;
+    }
+    let parent = listItem;
+    while (parent !== null) {
+        if ($isListItemNode(parent)) {
+            if (parent.getNextSiblings().length > 0) {
+                isLast = false;
+            }
+        }
+        parent = parent.getParent();
+    }
+    return isLast;
+}
+export default function RemoveListPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        return mergeRegister(editor.registerCommand(KEY_DOWN_COMMAND, (event) => {
+            const DELETE_CODE = ['Backspace', 'Delete'].map((key) => key.toLocaleLowerCase());
+            if (DELETE_CODE.includes(event.code.toLocaleLowerCase())) {
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    try {
+                        const anchorNode = selection.anchor.getNode();
+                        const listItemNode = $getNearestNodeOfType(anchorNode, ListItemNode);
+                        const isLastItemInList = listItemNode ? $isLastItemInList(listItemNode) : false;
+                        if (isLastItemInList && listItemNode) {
+                            if (!selection.anchor.offset) {
+                                event.preventDefault();
+                                const childrens = listItemNode.getChildren();
+                                const paragraph = $createParagraphNode();
+                                if (Array.isArray(childrens) && childrens.length) {
+                                    childrens.forEach((child) => {
+                                        paragraph.append(child);
+                                    });
+                                }
+                                listItemNode.insertAfter(paragraph);
+                                listItemNode.remove();
+                                selection.anchor.set(paragraph.getKey(), 0, 'element');
+                                selection.focus.set(paragraph.getKey(), 0, 'element');
+                                return true;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error(error);
+                        return false;
+                    }
+                }
+            }
+            return false;
+        }, COMMAND_PRIORITY_CRITICAL));
+    }, [editor]);
+    return null;
+}

package/lib/ext/SafeAreaPlugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * - 在 editor 底部增加一个 30vh 的安全区域
+ * - 仅在 edit mode 下生效
+ * - 在 comment list 这种纵向空间有限的场景建议禁用该插件
+ */
+export declare function SafeAreaPlugin({ size }: {
+    size?: number | string;
+}): null;
+export declare function useSafeArea({ enabled, size }: {
+    enabled: boolean;
+    size?: number | string;
+}): void;

package/lib/ext/SafeAreaPlugin.js

@@ -0,0 +1,56 @@
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useEffect, useRef } from 'react';
+const normalizeCssSize = (size) => {
+    if (typeof size === 'number') {
+        return `${size}px`;
+    }
+    return size;
+};
+/**
+ * - 在 editor 底部增加一个 30vh 的安全区域
+ * - 仅在 edit mode 下生效
+ * - 在 comment list 这种纵向空间有限的场景建议禁用该插件
+ */
+export function SafeAreaPlugin({ size = '30vh' }) {
+    const [editor] = useLexicalComposerContext();
+    const originalValue = useRef(undefined);
+    // TODO: editable true->false 时恢复原值
+    // const restore = () => {
+    //   const rootElement = editor.getRootElement();
+    //   if (rootElement) {
+    //     rootElement.style.paddingBottom = originalValue.current || '';
+    //   }
+    // };
+    useEffect(() => {
+        return editor.registerRootListener((rootElement, prevRootElement) => {
+            if (rootElement !== null && editor.isEditable()) {
+                if (originalValue.current === undefined) {
+                    originalValue.current = rootElement.style.paddingBottom;
+                }
+                rootElement.style.paddingBottom = normalizeCssSize(size);
+            }
+        });
+    }, [editor]);
+    return null;
+}
+export function useSafeArea({ enabled, size = '30vh' }) {
+    const [editor] = useLexicalComposerContext();
+    const originalValue = useRef(undefined);
+    useEffect(() => {
+        const cleanup = editor.registerRootListener((rootElement, prevRootElement) => {
+            if (rootElement !== null && editor.isEditable() && enabled) {
+                if (originalValue.current === undefined) {
+                    originalValue.current = rootElement.style.paddingBottom;
+                }
+                rootElement.style.paddingBottom = normalizeCssSize(size);
+            }
+        });
+        return () => {
+            const rootElement = editor.getRootElement();
+            if (rootElement && originalValue.current !== undefined) {
+                rootElement.style.paddingBottom = originalValue.current;
+            }
+            cleanup();
+        };
+    }, [editor, enabled]);
+}

package/lib/ext/SelectBlockPlugin.d.ts

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

package/lib/ext/SelectBlockPlugin.js

@@ -0,0 +1,95 @@
+import { useEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getSelection, $isRangeSelection, $isElementNode, $isTextNode, KEY_DOWN_COMMAND, COMMAND_PRIORITY_CRITICAL, } from 'lexical';
+import { $selectAll } from '@lexical/selection';
+import { IS_APPLE } from '../shared/environment';
+export default function SelectBlockWrapper() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        return editor.registerCommand(KEY_DOWN_COMMAND, (event) => {
+            if (event.keyCode === 65 && (IS_APPLE ? event.metaKey : event.ctrlKey)) {
+                event.preventDefault();
+                editor.update(() => {
+                    const selection = $getSelection();
+                    if ($isRangeSelection(selection)) {
+                        // 是否是从底部开始选择
+                        const isBottomToToSelect = selection.isBackward();
+                        // 选区的起始节点
+                        const { anchor } = selection;
+                        // 选区的结束节点
+                        const { focus } = selection;
+                        // 选区起始节点所在的最顶层元素
+                        const anchorTopLevelElement = anchor.getNode().getTopLevelElementOrThrow();
+                        // 选区结束节点所在的最顶层元素
+                        const focusTopLevelElement = focus.getNode().getTopLevelElementOrThrow();
+                        // 选区起始节点
+                        let anchorNode = isBottomToToSelect
+                            ? anchorTopLevelElement.getLastDescendant()
+                            : anchorTopLevelElement.getFirstDescendant();
+                        // 选区结束节点
+                        let focusNode = isBottomToToSelect
+                            ? focusTopLevelElement.getFirstDescendant()
+                            : focusTopLevelElement.getLastDescendant();
+                        /**
+                         * 设置选择区域
+                         * @param anchorOffset 起始偏移量
+                         * @param focusOffset 结束偏移量
+                         * @param anchorType 起始类型
+                         * @param lastType 结束类型
+                         */
+                        const setSelection = ({ anchorOffset, focusOffset, anchorType, focusType, }) => {
+                            if (anchor.offset === anchorOffset && focus.offset === focusOffset) {
+                                $selectAll(selection);
+                            }
+                            else {
+                                anchor.set(anchorNode.getKey(), anchorOffset, anchorType);
+                                focus.set(focusNode.getKey(), focusOffset, focusType);
+                            }
+                        };
+                        let anchorType = 'element'; // 锚点类型，默认为 element
+                        let focusType = 'element'; // 焦点类型，默认为 element
+                        let anchorOffset = 0; // 锚点偏移量
+                        let focusOffset = 0; // 焦点偏移量
+                        if ($isTextNode(anchorNode)) {
+                            // 如果锚点为文本节点
+                            anchorType = 'text'; // 锚点类型设置为 text
+                            anchorOffset = anchorNode.getTextContentSize(); // 锚点偏移量设置为文本内容长度
+                        }
+                        else if (!$isElementNode(anchorNode) && anchorNode !== null) {
+                            // 如果锚点不是元素节点，并且不为 null
+                            // eslint-disable-next-line no-self-assign
+                            anchorNode = anchorNode;
+                        }
+                        else {
+                            anchorNode = anchorTopLevelElement; // 锚点设置为父节点
+                        }
+                        if ($isTextNode(focusNode)) {
+                            // 如果焦点为文本节点
+                            focusType = 'text'; // 焦点类型设置为 text
+                            focusOffset = focusNode.getTextContentSize(); // 焦点偏移量设置为文本内容长度
+                        }
+                        else if (!$isElementNode(focusNode) && focusNode !== null) {
+                            // 如果焦点不是元素节点，并且不为 null
+                            // eslint-disable-next-line no-self-assign
+                            focusNode = focusNode;
+                        }
+                        else {
+                            focusNode = focusTopLevelElement; // 焦点设置为父节点
+                        }
+                        if (anchorNode && focusNode) {
+                            setSelection({
+                                anchorOffset: isBottomToToSelect ? anchorOffset : 0,
+                                focusOffset: isBottomToToSelect ? 0 : focusOffset,
+                                anchorType,
+                                focusType,
+                            });
+                        }
+                    }
+                });
+                return false;
+            }
+            return false;
+        }, COMMAND_PRIORITY_CRITICAL);
+    }, [editor]);
+    return null;
+}

package/lib/ext/ShortcutPlugin/CtrlsShortcutPlugin.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+interface Props {
+    callback: () => void;
+}
+export declare function CtrlsShortcutPlugin({ callback }: Props): React.ReactElement<any> | null;
+export default CtrlsShortcutPlugin;

package/lib/ext/ShortcutPlugin/CtrlsShortcutPlugin.js

@@ -0,0 +1,17 @@
+import { useEffect } from 'react';
+export function CtrlsShortcutPlugin({ callback }) {
+    useEffect(() => {
+        const handleKeyDown = (e) => {
+            if (e.key === 's' && (e.metaKey || e.ctrlKey)) {
+                e.preventDefault();
+                callback();
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [callback]);
+    return null;
+}
+export default CtrlsShortcutPlugin;

package/lib/ext/ShortcutPlugin/index.d.ts

@@ -0,0 +1 @@
+export { CtrlsShortcutPlugin } from './CtrlsShortcutPlugin';

package/lib/ext/ShortcutPlugin/index.js

@@ -0,0 +1 @@
+export { CtrlsShortcutPlugin } from './CtrlsShortcutPlugin';

package/lib/ext/TemplatePlugin.d.ts

@@ -0,0 +1,8 @@
+import { type JSX } from 'react';
+export declare const INSERT_TEMPLATE_COMMAND: import("lexical").LexicalCommand<unknown>;
+export declare function TemplatePlugin(): JSX.Element | null;
+export declare function TemplateSelect({ onSelect, onHover, templateList, }: {
+    onSelect: (item: any) => void;
+    onHover: (item: any) => void;
+    templateList?: any[];
+}): import("react/jsx-runtime").JSX.Element;