@blocklet/editor-lite 2.6.0

package/lib/ext/AIPlugin/index.js

@@ -0,0 +1,180 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { createDOMRange, createRectsFromDOMRange } from '@lexical/selection';
+import Box from '@mui/material/Box';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_NORMAL, createCommand, } from 'lexical';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { mergeRegister } from '@lexical/utils';
+import { SelectionPopper } from '../../components/SelectionPopper';
+import { useEditorConfig } from '../../config';
+import { Aide, AideProvider, useAideContext } from '../Aide';
+import TextGeneration from './TextGeneration';
+import { replace, insertBelow, copy } from './utils';
+import AIKitIcon from './AIIcon';
+import { useAIAvailable } from '../Aide/hooks';
+export const ACTIVATE_AI_COMMAND = createCommand('ACTIVATE_AI_COMMAND');
+// AI external templates 可用时通过该命令与 editor 其它插件通讯
+export const AI_TEMPLATES_AVAILABLE_COMMAND = createCommand('AI_TEMPLATES_AVAILABLE_COMMAND');
+const globalStates = { templatesAvailable: false };
+export function AideFloatingToolbarButton({ onClick }) {
+    const [editor] = useLexicalComposerContext();
+    const { available } = useAIAvailable();
+    return (_jsx("button", { disabled: !available, onClick: () => {
+            editor.dispatchCommand(ACTIVATE_AI_COMMAND, 'normal');
+            onClick?.();
+        }, className: "popup-item spaced", "aria-label": "Ask AI", children: _jsx(AIKitIcon, { disabled: !available }) }));
+}
+export function AideToolbarButton() {
+    const [editor] = useLexicalComposerContext();
+    const { available } = useAIAvailable();
+    const [templatesAvailable, setTemplatesAvailable] = useState(globalStates.templatesAvailable);
+    useEffect(() => {
+        return mergeRegister(editor.registerCommand(AI_TEMPLATES_AVAILABLE_COMMAND, (payload) => {
+            setTemplatesAvailable(payload);
+            globalStates.templatesAvailable = payload;
+            return false;
+        }, COMMAND_PRIORITY_NORMAL));
+    }, [editor]);
+    return (_jsx(Box, { component: "button", disabled: !editor.isEditable() || !available || !templatesAvailable, onClick: () => {
+            editor.dispatchCommand(ACTIVATE_AI_COMMAND, 'templates');
+        }, className: "toolbar-item aide", sx: { svg: { opacity: 0.6 } }, children: _jsx("i", { className: "iconify", "data-icon": "tabler:sparkles" }) }));
+}
+function AideBox({ editor }) {
+    const boxRef = useRef(null);
+    const selectionState = useMemo(() => {
+        const container = document.createElement('div');
+        container.style.position = 'relative';
+        container.style.zIndex = '0';
+        return {
+            container,
+            elements: [],
+        };
+    }, []);
+    // FIXME: 参考 lexical playground 中的 MentionPlugin 代码, 用于 editor 失去焦点时保持 selection, 页面滚动时有飘移问题
+    const updateLocation = useCallback(() => {
+        editor.getEditorState().read(() => {
+            const selection = $getSelection();
+            if ($isRangeSelection(selection)) {
+                const { anchor } = selection;
+                const { focus } = selection;
+                const range = createDOMRange(editor, anchor.getNode(), anchor.offset, focus.getNode(), focus.offset);
+                const boxElem = boxRef.current;
+                if (range !== null && boxElem !== null) {
+                    const { left, bottom, width } = range.getBoundingClientRect();
+                    const selectionRects = createRectsFromDOMRange(editor, range);
+                    let correctedLeft = selectionRects.length === 1 ? left + width / 2 - 500 : left - 500;
+                    if (correctedLeft < 10) {
+                        correctedLeft = 10;
+                    }
+                    boxElem.style.left = `${correctedLeft}px`;
+                    // boxElem.style.top = `${bottom + 20}px`;
+                    boxElem.style.top = `${bottom}px`;
+                    const selectionRectsLength = selectionRects.length;
+                    const { container } = selectionState;
+                    const { elements } = selectionState;
+                    const elementsLength = elements.length;
+                    for (let i = 0; i < selectionRectsLength; i++) {
+                        const selectionRect = selectionRects[i];
+                        let elem = elements[i];
+                        if (elem === undefined) {
+                            elem = document.createElement('span');
+                            // @ts-ignore
+                            elements[i] = elem;
+                            container.appendChild(elem);
+                        }
+                        const color = '0, 122, 255';
+                        const style = `position:fixed;top:${selectionRect.top}px;left:${selectionRect.left}px;height:${selectionRect.height}px;width:${selectionRect.width}px;background-color:rgba(${color}, 0.3);pointer-events:none;z-index:5;`;
+                        elem.style.cssText = style;
+                    }
+                    for (let i = elementsLength - 1; i >= selectionRectsLength; i--) {
+                        const elem = elements[i];
+                        container.removeChild(elem);
+                        elements.pop();
+                    }
+                }
+            }
+        });
+    }, [editor]);
+    useLayoutEffect(() => {
+        updateLocation();
+        const { container } = selectionState;
+        const { body } = document;
+        if (body !== null) {
+            body.appendChild(container);
+            return () => {
+                body.removeChild(container);
+            };
+        }
+    }, [selectionState.container, updateLocation]);
+    useEffect(() => {
+        window.addEventListener('resize', updateLocation);
+        return () => {
+            window.removeEventListener('resize', updateLocation);
+        };
+    }, [updateLocation]);
+    // fix 页面滚动时文本 selection 高亮飘移的问题
+    useEffect(() => {
+        document.addEventListener('scroll', updateLocation, true);
+        return () => {
+            document.removeEventListener('scroll', updateLocation, true);
+        };
+    }, [updateLocation]);
+    return _jsx("div", { ref: boxRef });
+}
+function AidePlugin() {
+    const [editor] = useLexicalComposerContext();
+    const { available, status, externalTemplates, activateAI } = useAideContext();
+    const selectionRef = useRef(null);
+    useEffect(() => {
+        editor.dispatchCommand(AI_TEMPLATES_AVAILABLE_COMMAND, externalTemplates.templates.length > 0);
+    }, [externalTemplates]);
+    useEffect(() => {
+        return editor.registerCommand(ACTIVATE_AI_COMMAND, (mode) => {
+            return editor.getEditorState().read(() => {
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    activateAI({
+                        mode,
+                        selectionText: selection?.getTextContent() || '',
+                        selection: selection?.clone(),
+                    });
+                    selectionRef.current = selection;
+                    return true;
+                }
+                return false;
+            });
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [editor]);
+    const restoreSelection = () => {
+        editor.update(() => {
+            const selection = $getSelection();
+            if (selection !== null) {
+                selection.dirty = true;
+            }
+        });
+    };
+    useEffect(() => {
+        if (status === 'initial') {
+            restoreSelection();
+        }
+    }, [status]);
+    return (_jsxs(_Fragment, { children: [status !== 'initial' && createPortal(_jsx(AideBox, { editor: editor }), document.body), _jsx(TextGeneration, {}), _jsx(SelectionPopper, { selection: status !== 'initial' ? selectionRef.current : null, sx: { zIndex: 1000 }, children: _jsx(Aide, {}) })] }));
+}
+export default function AidePluginWrapper() {
+    const { AI } = useEditorConfig();
+    const [editor] = useLexicalComposerContext();
+    if (AI) {
+        const _replaceSelection = (selection, output) => {
+            replace(editor, selection, output);
+        };
+        const _insertBelow = (selection, output) => {
+            insertBelow(editor, selection, output);
+        };
+        const _copy = (output) => {
+            copy(output);
+        };
+        return (_jsx(AideProvider, { completions: AI.completions, replaceSelection: _replaceSelection, copy: _copy, insertBelow: _insertBelow, children: _jsx(AidePlugin, {}) }));
+    }
+    return null;
+}

package/lib/ext/AIPlugin/utils.d.ts

@@ -0,0 +1,6 @@
+import { LexicalEditor } from 'lexical';
+export declare const insertBelow: (editor: LexicalEditor, selection: any, text: string) => void;
+export declare const copy: (text: string) => void;
+export declare const insert: (editor: LexicalEditor, range: Range, text: string) => void;
+export declare const replace: (editor: LexicalEditor, selection: any, text: string) => void;
+export declare const getParagraphText: (editor: LexicalEditor) => string | undefined;

package/lib/ext/AIPlugin/utils.js

@@ -0,0 +1,44 @@
+import { $findMatchingParent } from '@lexical/utils';
+import { $createParagraphNode, $createRangeSelection, $createTextNode, $getSelection, $isRangeSelection, $setSelection, INSERT_LINE_BREAK_COMMAND, } from 'lexical';
+import { $getDepth } from '../../lexical-utils';
+export const insertBelow = (editor, selection, text) => {
+    editor.update(() => {
+        if ($isRangeSelection(selection)) {
+            const secondLevelParentNode = $findMatchingParent(selection.anchor.getNode(), (node) => $getDepth(node) === 1);
+            secondLevelParentNode.selectEnd();
+            editor.dispatchCommand(INSERT_LINE_BREAK_COMMAND, false);
+            const paragraphNode = $createParagraphNode();
+            const textNode = $createTextNode(text);
+            paragraphNode.append(textNode);
+            $getSelection()?.insertNodes(paragraphNode.getAllTextNodes());
+        }
+    });
+};
+export const copy = (text) => {
+    navigator.clipboard.writeText(text);
+};
+export const insert = (editor, range, text) => {
+    editor.update(() => {
+        const s = $createRangeSelection();
+        s.applyDOMRange(range);
+        s.insertNodes([$createTextNode(` ${text}`)]);
+    });
+};
+export const replace = (editor, selection, text) => {
+    editor.update(() => {
+        if ($isRangeSelection(selection)) {
+            $setSelection(selection);
+            const s = $getSelection();
+            s?.insertText(text);
+        }
+    });
+};
+export const getParagraphText = (editor) => {
+    return editor.getEditorState().read(() => {
+        const selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+            const secondLevelParentNode = $findMatchingParent(selection.anchor.getNode(), (node) => $getDepth(node) === 1);
+            return secondLevelParentNode?.getTextContent();
+        }
+    });
+};

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

@@ -0,0 +1,9 @@
+import { LexicalCommand } from 'lexical';
+import type { TranslateAPI } from './types';
+export declare const AI_TRANSLATE_AVAILABLE_COMMAND: LexicalCommand<boolean>;
+export declare function AITranslateToolbarButton(): import("react/jsx-runtime").JSX.Element | null;
+interface Props {
+    translateAPI?: TranslateAPI;
+}
+export default function AITranslationPlugin(props: Props): null;
+export {};

package/lib/ext/AITranslationPlugin/index.js

@@ -0,0 +1,124 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { Button, Box, Popover, ClickAwayListener, FormControl, MenuItem, Select, InputLabel, Backdrop, Snackbar, Alert, styled, LinearProgress, linearProgressClasses, Paper, } from '@mui/material';
+import { COMMAND_PRIORITY_NORMAL, createCommand } from 'lexical';
+import { useEffect, useLayoutEffect, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { mergeRegister } from '@lexical/utils';
+import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
+import { blockletExists } from '../utils';
+import { translateFullContent } from './translation';
+// editor key <=> available
+const availableStates = {};
+export const AI_TRANSLATE_AVAILABLE_COMMAND = createCommand('AI_TRANSLATE_AVAILABLE_COMMAND');
+const BorderLinearProgress = styled(LinearProgress)(({ theme }) => ({
+    width: '100%',
+    height: 10,
+    borderRadius: 5,
+    [`&.${linearProgressClasses.colorPrimary}`]: {
+        backgroundColor: theme.palette.grey[theme.palette.mode === 'light' ? 200 : 800],
+    },
+    [`& .${linearProgressClasses.bar}`]: {
+        borderRadius: 5,
+        bgcolor: 'primary',
+    },
+}));
+function Wait({ open, progress, targetLanguage, onCancel, }) {
+    return (_jsx(Backdrop, { sx: { bgcolor: 'transparent', zIndex: (theme) => theme.zIndex.drawer + 1 }, open: open, children: _jsxs(Paper, { sx: {
+                display: 'flex',
+                flexDirection: 'column',
+                alignItems: 'center',
+                width: { xs: 360, md: 420, lg: 480 },
+                maxWidth: '100%',
+                px: 4,
+                py: 3,
+            }, elevation: 3, children: [_jsx(Box, { sx: { mb: 4, color: 'grey.800', fontSize: 20, fontWeight: 'bold' }, children: "Translating" }), _jsx(BorderLinearProgress, { variant: "determinate", value: progress }), _jsxs(Box, { sx: { mt: 3, color: 'grey.600', fontSize: 14, fontWeight: 'bold' }, children: ["Translating content to ", targetLanguage, ". Please be patient."] }), _jsx(Button, { variant: "outlined", color: "inherit", sx: { mt: 3 }, onClick: onCancel, children: "Cancel" })] }) }));
+}
+export function AITranslateToolbarButton() {
+    const [editor] = useLexicalComposerContext();
+    const { languages = [] } = useLocaleContext() || {};
+    const [available, setAvailable] = useState(!!availableStates[editor.getKey()]);
+    const [anchorEl, setAnchorEl] = useState(null);
+    const [targetLanguage, setTargetLanguage] = useState(languages[0]?.name);
+    const [translating, setTranslating] = useState(false);
+    const [progress, setProgress] = useState(1);
+    const [error, setError] = useState(null);
+    const [abortController, setAbortController] = useState(null);
+    const handleClick = (event) => {
+        setAnchorEl(event.currentTarget);
+    };
+    const handleClose = () => {
+        setAnchorEl(null);
+    };
+    const handleClickAway = () => {
+        if (!translating) {
+            handleClose();
+        }
+    };
+    useLayoutEffect(() => {
+        return mergeRegister(editor.registerCommand(AI_TRANSLATE_AVAILABLE_COMMAND, (payload) => {
+            setAvailable(payload);
+            return false;
+        }, COMMAND_PRIORITY_NORMAL));
+    }, [editor]);
+    if (!available) {
+        return null;
+    }
+    const handleTranslate = async () => {
+        try {
+            const controller = new AbortController();
+            setAbortController(controller);
+            setTranslating(true);
+            setTimeout(() => handleClose());
+            await translateFullContent(editor, {
+                targetLanguage,
+                onProgress: (v) => setProgress(v),
+                signal: controller.signal,
+            });
+        }
+        catch (e) {
+            console.error(e);
+            setError(e);
+        }
+        finally {
+            setTranslating(false);
+            setProgress(1);
+            setAbortController(null);
+        }
+    };
+    const handleCancel = () => {
+        abortController?.abort();
+        setTranslating(false);
+        setProgress(1);
+        setAbortController(null);
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(Box, { component: "button", disabled: !editor.isEditable(), onClick: handleClick, className: "toolbar-item spaced", sx: { '.iconify': { display: 'flex', alignItems: 'center', fontSize: 18, opacity: 0.6 } }, children: [_jsx("i", { className: "iconify", "data-icon": "ri:translate" }), _jsx(Popover, { open: !!anchorEl, anchorEl: anchorEl, onClose: handleClose, transformOrigin: {
+                            vertical: 'top',
+                            horizontal: 'right',
+                        }, anchorOrigin: {
+                            vertical: 'bottom',
+                            horizontal: 'right',
+                        }, elevation: 1, sx: { mt: 1 }, children: _jsx(ClickAwayListener, { onClickAway: handleClickAway, children: _jsxs(Box, { sx: {
+                                    p: 3,
+                                    border: 1,
+                                    borderColor: 'grey.300',
+                                    borderRadius: 2,
+                                    bgcolor: '#fff',
+                                    boxShadow: '0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)',
+                                }, children: [_jsx(Box, { sx: { minWidth: 240 }, children: _jsxs(FormControl, { fullWidth: true, size: "small", children: [_jsx(InputLabel, { children: "Target Language" }), _jsx(Select, { label: "Target Language", size: "small", value: targetLanguage, MenuProps: { disablePortal: true }, onChange: (e) => setTargetLanguage(e.target.value), children: languages.map((item) => (_jsx(MenuItem, { value: item.name, children: item.name }, item.name))) })] }) }), _jsx(Button, { variant: "contained", onClick: handleTranslate, disabled: !targetLanguage, sx: { width: 1, mt: 2 }, children: "Translate" })] }) }) })] }), createPortal(_jsxs(_Fragment, { children: [_jsx(Wait, { open: translating, progress: progress, targetLanguage: targetLanguage, onCancel: handleCancel }), _jsx(Snackbar, { open: !!error, autoHideDuration: 6000, anchorOrigin: { vertical: 'top', horizontal: 'right' }, onClose: () => setError(null), children: _jsx(Alert, { onClose: () => setError(null), severity: "error", sx: { width: '100%' }, children: error?.message || 'Translation failed' }) })] }), document.body)] }));
+}
+export default function AITranslationPlugin(props) {
+    const [editor] = useLexicalComposerContext();
+    const available = blockletExists('ai-kit');
+    useEffect(() => {
+        if (available) {
+            // 启用了 AITranslationPlugin 的 editor 实例才会在 toolbar 显示翻译按钮
+            availableStates[editor.getKey()] = true;
+            editor.dispatchCommand(AI_TRANSLATE_AVAILABLE_COMMAND, true);
+        }
+        return () => {
+            delete availableStates[editor.getKey()];
+        };
+    }, [editor]);
+    return null;
+}

package/lib/ext/AITranslationPlugin/selection.d.ts

@@ -0,0 +1,3 @@
+import { LexicalEditor } from 'lexical';
+import type { TranslationOptions, TranslationResult } from './types';
+export declare const translateSelection: (editor: LexicalEditor, options: TranslationOptions) => Promise<TranslationResult | null>;

package/lib/ext/AITranslationPlugin/selection.js

@@ -0,0 +1,45 @@
+import { $getSelection, $isRangeSelection } from 'lexical';
+import { $replaceTranslations, $extractTranslationBlocksFromSelection, defaultTranslateAPI, $preview, $insertTranslations, } from './utils';
+// const isTranslationBlockWithSelection = (o: any): o is TranslationBlockWithSelection => !!o.point;
+export const translateSelection = async (editor, options) => {
+    const selection = editor.getEditorState().read($getSelection);
+    if (!$isRangeSelection(selection) || selection.isCollapsed()) {
+        return null;
+    }
+    const translationBlocks = editor
+        .getEditorState()
+        .read(() => $extractTranslationBlocksFromSelection(editor, selection));
+    const { sourceLanguage, targetLanguage } = options;
+    const translateAPI = options.translateAPI || defaultTranslateAPI;
+    if (translationBlocks && translationBlocks.length > 0) {
+        const sourceTexts = translationBlocks.reduce((acc, cur) => ({ ...acc, [cur.key]: cur.text }), {});
+        const targetTexts = {};
+        await translateAPI({ texts: sourceTexts, sourceLanguage, targetLanguage }, ({ data, progress }) => {
+            targetTexts[data.key] = data.text;
+            if (options.onProgress && progress) {
+                options.onProgress(progress);
+            }
+        });
+        const translations = translationBlocks.map((item, index) => ({
+            ...item,
+            text: targetTexts[index] || sourceTexts[index],
+        }));
+        return {
+            translations,
+            preview: () => {
+                return editor.getEditorState().read(() => $preview(translations));
+            },
+            replace: () => {
+                editor.update(() => {
+                    $replaceTranslations(editor, translations);
+                });
+            },
+            insertBelow: () => {
+                editor.update(() => {
+                    $insertTranslations(translations, selection);
+                });
+            },
+        };
+    }
+    return null;
+};

package/lib/ext/AITranslationPlugin/translation.d.ts

@@ -0,0 +1,3 @@
+import { type LexicalEditor } from 'lexical';
+import type { TranslationOptions, TranslationResult } from './types';
+export declare const translateFullContent: (editor: LexicalEditor, options: TranslationOptions) => Promise<TranslationResult | null>;

package/lib/ext/AITranslationPlugin/translation.js

@@ -0,0 +1,67 @@
+import { $extractTranslationBlocks, $preview, $replaceTranslations, defaultTranslateAPI } from './utils';
+export const translateFullContent = async (editor, options) => {
+    const { sourceLanguage, targetLanguage, signal } = options;
+    const translateAPI = options.translateAPI || defaultTranslateAPI;
+    let translationBlocks = [];
+    editor.update(() => {
+        translationBlocks = $extractTranslationBlocks(editor);
+    }, { discrete: true });
+    // eslint-disable-next-line no-console
+    console.log('translationBlocks: ', translationBlocks);
+    if (translationBlocks) {
+        const sourceTexts = translationBlocks.reduce((acc, cur) => ({ ...acc, [cur.key]: cur.text }), {});
+        const targetTexts = {};
+        const errorsMap = {};
+        await translateAPI({ texts: sourceTexts, sourceLanguage, targetLanguage }, ({ data, progress, error }) => {
+            const sourceText = sourceTexts[data.key];
+            if (error) {
+                targetTexts[data.key] = sourceText;
+                errorsMap[data.key] = error;
+            }
+            else {
+                targetTexts[data.key] = data.text;
+            }
+            if (options.onProgress && progress) {
+                options.onProgress(progress);
+            }
+        });
+        const translations = translationBlocks
+            .map((item) => {
+            const targetText = targetTexts[item.key];
+            return {
+                ...item,
+                // 注意判断类型, completions api 可能返回非字符串的格式, 如 `{ text: 'xxx' }`, 如果为非字符串则使用原来的文本(放弃替换)
+                text: typeof targetText === 'string' ? targetText : sourceTexts[item.key],
+            };
+        })
+            .filter((x) => !!x.text);
+        const errors = translationBlocks
+            .filter((x) => !!errorsMap[x.key])
+            .map((item) => ({ ...item, error: errorsMap[item.key] }));
+        // eslint-disable-next-line no-console
+        console.log('translations: ', translations);
+        // eslint-disable-next-line no-console
+        console.log('errors: ', errors);
+        // 默认自动替换
+        const autoReplace = options.autoReplace !== false;
+        if (autoReplace && !signal?.aborted) {
+            editor.update(() => {
+                $replaceTranslations(editor, translations);
+            });
+        }
+        return {
+            translations,
+            errors,
+            preview: () => {
+                return editor.getEditorState().read(() => $preview(translations));
+            },
+            replace: (e) => {
+                (e || editor).update(() => {
+                    $replaceTranslations(editor, translations);
+                });
+            },
+            insertBelow: () => { },
+        };
+    }
+    return null;
+};

package/lib/ext/AITranslationPlugin/types.d.ts

@@ -0,0 +1,49 @@
+import { LexicalEditor, LexicalNode } from 'lexical';
+import { PointType } from 'lexical/LexicalSelection';
+export interface TranslationBlock {
+    key: string;
+    text: string;
+}
+export interface TranslationBlockWithSelection extends TranslationBlock {
+    nodes: LexicalNode[];
+    point: PointType;
+}
+export interface NonTextNodeMatch {
+    key: string;
+    index: number;
+    length: number;
+}
+export interface TranslatePayload {
+    sourceLanguage?: string;
+    targetLanguage: string;
+    texts: {
+        [key: string]: string;
+    };
+}
+export type TranslateAPI = (payload: TranslatePayload, onData: ({ data, progress, error }: {
+    data: TranslationBlock;
+    progress?: number;
+    error?: string;
+}) => void) => Promise<void>;
+export interface TranslationOptions {
+    sourceLanguage?: string;
+    targetLanguage: string;
+    translateAPI?: TranslateAPI;
+    onProgress?: (progress: number) => void;
+    signal?: AbortSignal;
+    autoReplace?: boolean;
+}
+export interface TranslateSelectionOperations {
+    preview: () => string;
+    replace: (editor?: LexicalEditor) => void;
+    insertBelow: () => void;
+}
+export interface TranslationError {
+    key: string;
+    text: string;
+    error: string;
+}
+export interface TranslationResult extends TranslateSelectionOperations {
+    translations: TranslationBlock[];
+    errors?: TranslationError[];
+}

package/lib/ext/AITranslationPlugin/types.js

@@ -0,0 +1 @@
+export {};

package/lib/ext/AITranslationPlugin/utils.d.ts

@@ -0,0 +1,46 @@
+import { ElementNode, LexicalNode, RangeSelection, LexicalEditor } from 'lexical';
+import type { PointType } from 'lexical/LexicalSelection';
+import type { TranslationBlock, NonTextNodeMatch, TranslateAPI, TranslationBlockWithSelection } from './types';
+export declare const defaultTranslateAPI: TranslateAPI;
+export declare function $copyNodeDeep<T extends LexicalNode>(node: T): T;
+export declare const insertNodesAfter: (node: LexicalNode, nodesToInsert: LexicalNode[]) => void;
+/**
+ * 遍历顶层结点，获取需要翻译的结点列表
+ * - HeadingNode
+ * - ParagraphNode
+ * - ListItemNode
+ * - QuoteNode
+ */
+export declare const $extractTranslationNodes: (topLevelNodes: ElementNode[]) => ElementNode[];
+/**
+ * 以下 node 符合 translation node:
+ * - heading node
+ * - paragraph node
+ * - list item node
+ * - quote node
+ */
+export declare const $extractTextContentFromTranslationNode: (translationNode: ElementNode, selectedNodes?: LexicalNode[]) => string;
+export declare const $extractTranslationBlocks: (editor: LexicalEditor, translationNodes?: ElementNode[]) => TranslationBlock[];
+/**
+ * 处理带有 `###key###` 的文本, 将普通文本转成 TextNode, 将 `###key###` 替换成 key 对应的 Node
+ * @param {string} text - 如: "a ###1### b ###20### c"
+ * @param {NonTextNodeMatch[]} matches - 如: [{key: 1, index: 2, length: 7}, {key: 20, index: 12, length: 8}]
+ * @returns LexicalNode 数组, 如: [<text-node "a">, <node-key-1>, <text-node "b">, <node-key-20>, <text-node "c">, ]
+ */
+export declare const rearrangeNodes: (text: string, matches: NonTextNodeMatch[]) => LexicalNode[];
+/**
+ * 处理带有 `###key###` 的文本 (对应一个 translation node 的文本), 解析文本中 `###key###` 的信息,
+ * 包括 Node Key, 在文本中的 index, 自身字符长度
+ * 比如: "a ###1### b ###20### c" => [{key: 1, index: 2, length: 7}, {key: 20, index: 12, length: 8}]
+ */
+export declare const matchNonTextNodes: (text: string) => NonTextNodeMatch[];
+export declare const $replaceTranslation: (translationBlock: TranslationBlock, editor: LexicalEditor) => LexicalNode | ElementNode | null;
+export declare const $replaceTranslations: (editor: LexicalEditor, translationBlocks: TranslationBlock[]) => (LexicalNode | ElementNode | null)[];
+export declare const $insertTranslations: (translationBlocks: TranslationBlock[], selection: RangeSelection) => void;
+export declare const $preview: (translationBlocks: TranslationBlock[]) => string;
+/**
+ * TODO: 剥除未选中的部分
+ */
+export declare const $extractTranslationBlockWithSelection: (translationNode: ElementNode, point: PointType, backward?: boolean) => TranslationBlockWithSelection | null;
+export declare const getTopLevelNodesFromSelection: (selection: RangeSelection) => ElementNode[];
+export declare const $extractTranslationBlocksFromSelection: (editor: LexicalEditor, selection: RangeSelection) => TranslationBlockWithSelection[];