@blocklet/editor-lite 2.6.0

package/lib/ext/Aide/context.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useRef } from 'react';
+import { useGetState } from 'ahooks';
+import builtinTemplates from './builtin-templates';
+import { Template } from './types';
+import { useAIAvailable } from './hooks';
+export const AideContext = createContext({});
+export const useAideContext = () => useContext(AideContext);
+export function AideProvider({ completions, replaceSelection, insertBelow, copy, children }) {
+    const [state, setState, getState] = useGetState({
+        templates: builtinTemplates,
+        externalTemplates: { templates: [], hasMore: true, tags: [], tag: undefined, loading: false },
+        mode: 'normal',
+        status: 'initial',
+        selection: null,
+        selectionText: '',
+        input: '',
+        output: '',
+    });
+    // (external) "templates" mode 下可用的 builtin templates (以及 activeBuiltinTemplate) 为空
+    const filteredTemplates = useMemo(() => state.mode === 'normal'
+        ? state.templates.filter((item) => item.name?.toLowerCase().indexOf(state.input?.toLowerCase()) > -1)
+        : [], [state]);
+    const activeBuiltinTemplate = useMemo(() => {
+        const first = filteredTemplates[0];
+        return first?.hasOptions() ? undefined : first;
+    }, [filteredTemplates]);
+    const retryRef = useRef(null);
+    const reset = (params = {}, keepSelection = false, isCopy = false) => {
+        setState((prev) => ({
+            ...prev,
+            status: isCopy ? 'copied' : 'initial',
+            ...(!keepSelection && {
+                selection: null,
+                selectionText: '',
+            }),
+            input: '',
+            output: '',
+            ...params,
+        }));
+    };
+    // @deprecated
+    const loadMoreTemplates = async () => { };
+    const { available } = useAIAvailable();
+    const activateAI = useCallback(
+    // eslint-disable-next-line require-await
+    async ({ mode = 'normal', selectionText, selection }) => {
+        setState((prev) => ({ ...prev, mode, selectionText, selection, status: 'activated' }));
+    }, []);
+    const setInput = (text) => setState((prev) => ({ ...prev, input: text }));
+    const sendToAI = async (payload) => {
+        function isQuoted(str) {
+            return str.startsWith('"') && str.endsWith('"');
+        }
+        function removeQuotes(str) {
+            if (isQuoted(str)) {
+                return str.slice(1, -1);
+            }
+            return str;
+        }
+        let output = '';
+        setState((prev) => ({ ...prev, status: 'waiting' }));
+        retryRef.current = () => sendToAI(payload);
+        try {
+            // ad hoc prompt
+            if (typeof payload === 'string') {
+                output = await completions(payload);
+                // builtin template
+            }
+            else if (payload instanceof Template) {
+                output = await completions(payload.getPrompt(state.selectionText));
+                // parameterized template
+            }
+            else if (payload) {
+                output = await completions(payload);
+            }
+            if (!isQuoted(state.selectionText)) {
+                output = removeQuotes(output?.trim());
+            }
+            if (typeof output !== 'string') {
+                throw new Error('Invalid response message');
+            }
+            // waiting 时状态可能会改变 (比如 reset => 'initial')
+            if (getState().status === 'waiting') {
+                setState((prev) => ({ ...prev, output, status: 'completed' }));
+            }
+        }
+        catch (e) {
+            const latestState = getState();
+            console.error(e, { input: latestState.input, selection: latestState.selection, output });
+            setState((prev) => ({ ...prev, status: 'activated' }));
+        }
+    };
+    const retry = () => retryRef.current?.();
+    const stop = () => setState((prev) => ({ ...prev, status: 'activated' }));
+    const value = useMemo(() => ({
+        ...state,
+        available,
+        filteredTemplates,
+        activeBuiltinTemplate,
+        activateAI,
+        setInput,
+        sendToAI,
+        retry,
+        stop,
+        reset,
+        replaceSelection,
+        insertBelow,
+        copy,
+        completions,
+        loadMoreTemplates,
+    }), [state]);
+    return _jsx(AideContext.Provider, { value: value, children: children });
+}

package/lib/ext/Aide/external-templates/Breadcrumb.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+interface Item {
+    title: React.ReactNode;
+    onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+}
+interface Props {
+    items: Item[];
+}
+export default function Breadcrumb({ items, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/ext/Aide/external-templates/Breadcrumb.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Breadcrumbs } from '@mui/material';
+export default function Breadcrumb({ items, ...rest }) {
+    return (_jsx(Breadcrumbs, { sx: { fontSize: 14, lineHeight: 1 }, ...rest, children: items.map((item, index) => {
+            const isLast = index === items.length - 1;
+            const styles = isLast ? { color: 'grey.800', textDecoration: 'underline' } : {};
+            return (_jsx(Box
+            // eslint-disable-next-line react/no-array-index-key
+            , { onClick: item.onClick, sx: [{ cursor: 'pointer', '&:hover': { textDecoration: 'underline' } }, styles], children: item.title }, index));
+        }) }));
+}

package/lib/ext/Aide/external-templates/Output.d.ts

@@ -0,0 +1,8 @@
+import { ParameterizedTemplate } from '../types';
+interface Props {
+    template: ParameterizedTemplate;
+    gotoTemplatesView: () => void;
+    gotoTemplateView: (templateId: string) => void;
+}
+export default function OutputView({ template, gotoTemplatesView, gotoTemplateView, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/ext/Aide/external-templates/Output.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Box from '@mui/material/Box';
+import { Card } from '../../common';
+import { useAideContext } from '../context';
+import Menu from '../Menu';
+import Breadcrumb from './Breadcrumb';
+export default function OutputView({ template, gotoTemplatesView, gotoTemplateView, ...rest }) {
+    const { output } = useAideContext();
+    return (_jsxs(Box, { ...rest, children: [_jsx(Card, { sx: { maxHeight: 300, overflowY: 'auto', bgcolor: '#fff' }, children: _jsxs(Box, { sx: { p: 2 }, children: [_jsx(Breadcrumb, { items: [
+                                { title: 'Templates', onClick: gotoTemplatesView },
+                                {
+                                    title: (_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 0.5 }, children: [_jsx(Box, { sx: {
+                                                    display: 'flex',
+                                                    justifyContent: 'center',
+                                                    alignItems: 'center',
+                                                    flex: '0 0 auto',
+                                                }, children: _jsx(Box, { component: "i", className: "iconify", "data-icon": template.icon }) }), _jsx(Box, { children: template.name })] })),
+                                    onClick: () => gotoTemplateView(template.id),
+                                },
+                                { title: 'Output' },
+                            ] }), _jsx(Box, { sx: { width: 400, mt: 2 }, children: output })] }) }), _jsx(Box, { sx: { mt: 0.5 }, children: _jsx(Menu, {}) })] }));
+}

package/lib/ext/Aide/external-templates/Search.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    keyword: string;
+    onChange: (value: string) => void;
+}
+export default function Search({ keyword, onChange, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/ext/Aide/external-templates/Search.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Box from '@mui/material/Box';
+export default function Search({ keyword, onChange, ...rest }) {
+    const handleOnChange = (e) => {
+        onChange(e.target.value);
+    };
+    return (_jsxs(Box, { ...rest, sx: { display: 'flex', alignItems: 'center', height: 36, borderBottom: '1px solid #ddd' }, children: [_jsx(Box, { sx: {
+                    display: 'flex',
+                    justifyContent: 'center',
+                    alighItems: 'center',
+                    width: 36,
+                    color: 'grey.400',
+                }, children: _jsx(Box, { component: "i", className: "iconify", "data-icon": "mdi:magnify", "data-height": "18px" }) }), _jsx(Box, { component: "input", type: "text", value: keyword, onChange: handleOnChange, autoFocus: true, maxLength: 30, sx: { width: '100%', height: '100%', p: 0, border: 0, color: 'grey.700', outline: 'none' } })] }));
+}

package/lib/ext/Aide/external-templates/Tags.d.ts

@@ -0,0 +1,4 @@
+interface Props {
+}
+export default function Tags({ ...rest }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/ext/Aide/external-templates/Tags.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Tab, Tabs } from '@mui/material';
+import { useState } from 'react';
+import styled from '@emotion/styled';
+import { useAideContext } from '../context';
+export default function Tags({ ...rest }) {
+    const { externalTemplates: { tags }, loadMoreTemplates, } = useAideContext();
+    const [value, setValue] = useState(0);
+    const handleChange = (event, newValue) => {
+        setValue(newValue);
+    };
+    // FIXME: 暂时去除 Image tag
+    const filteredTags = tags?.filter((item) => item.toLowerCase() !== 'image') || [];
+    if (!filteredTags?.length) {
+        return null;
+    }
+    return (_jsx(Box, { ...rest, children: _jsxs(StyledTabs, { value: value, onChange: handleChange, variant: "scrollable", scrollButtons: "auto", children: [_jsx(Tab, { label: "All", disableRipple: true, onClick: () => loadMoreTemplates({ offset: 0 }) }), filteredTags?.map((item) => {
+                    return (_jsx(Tab, { label: item, disableRipple: true, onClick: () => loadMoreTemplates({ offset: 0, tag: item }) }, item));
+                })] }) }));
+}
+const StyledTabs = styled(Tabs) `
+  .MuiTabs-flexContainer {
+    position: relative;
+    z-index: 5;
+  }
+  .MuiTabs-indicator {
+    height: 28px;
+    top: 50%;
+    transform: translateY(-50%);
+    border-radius: 12px;
+  }
+  .MuiTabScrollButton-root {
+    width: auto;
+  }
+  .MuiTab-root {
+    min-width: 0;
+    padding: 4px 12px;
+    text-transform: initial;
+    transition: all 300ms cubic-bezier(0.4, 0, 0.2, 1) 0ms;
+  }
+  .MuiTab-root.Mui-selected {
+    color: #fff;
+  }
+`;

package/lib/ext/Aide/external-templates/Template.d.ts

@@ -0,0 +1,7 @@
+import { ParameterizedTemplate } from '../types';
+interface Props {
+    template: ParameterizedTemplate;
+    gotoTemplatesView: () => void;
+}
+export default function TemplateView({ template, gotoTemplatesView, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/ext/Aide/external-templates/Template.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, CircularProgress, Chip } from '@mui/material';
+import { ArrowForward as ArrowForwardIcon, Close as CloseIcon } from '@mui/icons-material';
+import Joi from 'joi';
+import { useMemo, useState } from 'react';
+import { useReactive } from 'ahooks';
+import pick from 'lodash/pick';
+import { Card, GradientButton } from '../../common';
+import { useAideContext } from '../context';
+import Breadcrumb from './Breadcrumb';
+import ParameterField from './parameter-field';
+export default function TemplateView({ template, gotoTemplatesView, ...rest }) {
+    const { status, sendToAI } = useAideContext();
+    const paramKeys = useMemo(() => template.parameters?.filter((i) => !!i.key).map((i) => i.key) ?? [], [template]);
+    const values = useReactive({});
+    const [error, setError] = useState();
+    const clearInputs = () => {
+        setError(undefined);
+        Object.keys(values).forEach((key) => {
+            values[key] = undefined;
+        });
+    };
+    const submit = () => {
+        setError(undefined);
+        const getValueSchema = (parameter) => {
+            return {
+                string: (param) => {
+                    let s = Joi.string();
+                    if (param.required) {
+                        s = s.required();
+                    }
+                    else {
+                        s = s.allow('');
+                    }
+                    if (typeof param.minLength === 'number') {
+                        s = s.min(param.minLength);
+                    }
+                    if (typeof param.maxLength === 'number') {
+                        s = s.max(param.maxLength);
+                    }
+                    return s;
+                },
+                number: (param) => {
+                    let s = Joi.number();
+                    if (param.required) {
+                        s = s.required();
+                    }
+                    if (typeof param.min === 'number') {
+                        s = s.min(param.min);
+                    }
+                    if (typeof param.max === 'number') {
+                        s = s.max(param.max);
+                    }
+                    return s;
+                },
+                select: (param) => {
+                    let s = Joi.string();
+                    if (param.required) {
+                        s = s.required();
+                    }
+                    return s;
+                },
+                language: (param) => {
+                    let s = Joi.string();
+                    if (param.required) {
+                        s = s.required();
+                    }
+                    return s;
+                },
+            }[parameter.type || 'string'](parameter);
+        };
+        const schema = Joi.object(Object.fromEntries((template.parameters ?? [])
+            .map((parameter) => {
+            if (!parameter.key)
+                return undefined;
+            return [parameter.key, getValueSchema(parameter)];
+        })
+            .filter((i) => !!i)));
+        // eslint-disable-next-line @typescript-eslint/no-shadow
+        const { error, value } = schema.validate(values, { allowUnknown: true, abortEarly: false });
+        if (error) {
+            setError(error);
+            return;
+        }
+        sendToAI({
+            ...pick(template, 'source', 'projectId', 'ref', 'resourceComponentDid'),
+            assistantId: template.id,
+            parameters: value,
+        });
+    };
+    return (_jsx(Card, { sx: { maxHeight: 440, overflowY: 'auto', bgcolor: '#fff' }, children: _jsxs(Box, { component: "form", ...rest, sx: { p: 2 }, children: [_jsx(Breadcrumb, { items: [
+                        { title: 'Templates', onClick: gotoTemplatesView },
+                        {
+                            title: (_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 0.5 }, children: [_jsx(Box, { sx: {
+                                            display: 'flex',
+                                            justifyContent: 'center',
+                                            alignItems: 'center',
+                                            flex: '0 0 auto',
+                                        }, children: _jsx(Box, { component: "i", className: "iconify", "data-icon": template.icon }) }), _jsx(Box, { children: template.name })] })),
+                        },
+                    ] }), _jsx(Box, { sx: { mt: 3 }, children: template.parameters?.map((parameter) => {
+                        if (!parameter.key)
+                            return;
+                        const paramKey = parameter.key;
+                        const err = error?.details.find((i) => i.path[0] === paramKey);
+                        return (_jsx(Box, { sx: { '& + &': { mt: 2 } }, children: _jsx(ParameterField, { fullWidth: true, size: "small", label: parameter.label || paramKey, parameter: parameter, error: !!err, helperText: err?.message ?? parameter.helper, value: values[paramKey] ?? '', onChange: (value) => {
+                                    values[paramKey] = value;
+                                } }) }, paramKey));
+                    }) }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', mt: 3 }, children: [Object.keys(values).length > 0 && (_jsx(Chip, { icon: _jsx(CloseIcon, {}), size: "small", label: "Clear Inputs", onClick: clearInputs })), _jsx(GradientButton, { variant: "contained", size: "small", onClick: submit, endIcon: status === 'waiting' ? (_jsx(CircularProgress, { size: 16, style: { color: '#fff' } })) : (_jsx(ArrowForwardIcon, { style: { fontSize: 18 } })), sx: { ml: 'auto' }, children: "Generate" })] })] }) }));
+}

package/lib/ext/Aide/external-templates/Templates.d.ts

@@ -0,0 +1,6 @@
+import { ParameterizedTemplate } from '../types';
+interface Props {
+    onSelect: (template: ParameterizedTemplate) => void;
+}
+export default function TemplatesView({ onSelect, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/ext/Aide/external-templates/Templates.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Typography, alpha, useTheme, CircularProgress } from '@mui/material';
+import { useRef, useState } from 'react';
+import { useInfiniteScroll } from 'ahooks';
+import { Card } from '../../common';
+import { useAideContext } from '../context';
+import Search from './Search';
+import Tags from './Tags';
+export default function TemplatesView({ onSelect, ...rest }) {
+    const theme = useTheme();
+    const { externalTemplates: { templates, hasMore, tag, loading }, loadMoreTemplates, } = useAideContext();
+    const [state, setState] = useState({ keyword: '' });
+    const containerRef = useRef(null);
+    // @ts-ignore
+    useInfiniteScroll(() => loadMoreTemplates({ tag }), {
+        target: containerRef,
+        manual: true,
+        threshold: hasMore ? 50 : -1,
+    });
+    // 1. 搜索匹配
+    let filteredTemplates = state.keyword
+        ? templates?.filter((template) => `${template.name} ${template.description}`.toLowerCase().indexOf(state.keyword.toLowerCase()) > -1)
+        : templates;
+    // 2. (临时) 过滤掉图片生成类形的 template
+    filteredTemplates = filteredTemplates.filter((item) => item.type !== 'image');
+    return (_jsx(Box, { sx: { position: 'relative' }, ...rest, children: _jsxs(Card, { ref: containerRef, sx: { height: 360, overflowY: 'auto', bgcolor: '#fff' }, children: [_jsx(Search, { keyword: state.keyword, onChange: (value) => setState((prev) => ({ ...prev, keyword: value })) }), _jsx(Tags, {}), _jsxs(Box, { sx: { mt: 0.5 }, children: [filteredTemplates.map((item) => {
+                            return (_jsxs(Box, { onClick: () => onSelect(item), sx: {
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    py: 0.25,
+                                    overflow: 'hidden',
+                                    cursor: 'pointer',
+                                    '&:hover': { bgcolor: alpha(theme.palette.primary.main, 0.1) },
+                                }, children: [_jsx(Box, { sx: {
+                                            display: 'flex',
+                                            justifyContent: 'center',
+                                            alignItems: 'center',
+                                            flex: '0 0 auto',
+                                            width: 64,
+                                            height: 56,
+                                        }, children: _jsx(Box, { component: "i", className: "iconify", "data-icon": item.icon, "data-height": "28px" }) }), _jsxs(Box, { sx: { pr: 2, overflow: 'hidden' }, children: [_jsx(Typography, { variant: "inherit", noWrap: true, sx: { fontSize: 14 }, children: item.name }), _jsx(Typography, { variant: "inherit", noWrap: true, sx: { fontSize: 12 }, children: item.description })] })] }, item.id));
+                        }), loading && (_jsx(Box, { sx: {
+                                display: 'flex',
+                                justifyContent: 'center',
+                                alignItems: 'center',
+                                position: 'absolute',
+                                top: 0,
+                                bottom: 0,
+                                width: '100%',
+                                my: 1.5,
+                            }, children: _jsx(Box, { sx: {
+                                    display: 'flex',
+                                    justifyContent: 'center',
+                                    alignItems: 'center',
+                                    width: 56,
+                                    height: 56,
+                                    bgcolor: 'grey.100',
+                                    borderRadius: 4,
+                                    boxShadow: 'box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);',
+                                }, children: _jsx(CircularProgress, { size: "24px" }) }) }))] })] }) }));
+}

package/lib/ext/Aide/external-templates/index.d.ts

@@ -0,0 +1,4 @@
+interface Props {
+}
+export default function ExternalTemplates({ ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/ext/Aide/external-templates/index.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, ClickAwayListener, useTheme, alpha } from '@mui/material';
+import { useEffect, useState } from 'react';
+import { useAideContext } from '../context';
+import Templates from './Templates';
+import Template from './Template';
+import Menu from '../Menu';
+import Input from '../Input';
+import Output from '../Output';
+import OutputView from './Output';
+const getInitialState = (partial) => ({
+    currentTemplate: null,
+    currentView: null,
+    ...partial,
+});
+export default function ExternalTemplates({ ...rest }) {
+    const theme = useTheme();
+    const { status, externalTemplates: { templates }, reset, } = useAideContext();
+    const [state, setState] = useState(getInitialState());
+    useEffect(() => {
+        if (state.currentView === 'template' && status === 'completed') {
+            setCurrentView('output');
+        }
+    }, [state, status]);
+    const setCurrentView = (view, params) => {
+        switch (view) {
+            case 'templates': {
+                setState(getInitialState({ currentView: 'templates' }));
+                reset({ status: 'activated' }, true);
+                break;
+            }
+            case 'template': {
+                if (!params?.id) {
+                    console.warn('Template ID is missing');
+                    return;
+                }
+                reset({ status: 'activated' }, true);
+                setState((prev) => ({
+                    ...prev,
+                    currentView: 'template',
+                    currentTemplate: templates.find((item) => item.id === params.id),
+                }));
+                break;
+            }
+            case 'output': {
+                setState((prev) => ({ ...prev, currentView: 'output' }));
+                break;
+            }
+            default: {
+                setState(getInitialState({ currentView: null }));
+                reset({ status: 'activated' }, true);
+            }
+        }
+    };
+    const gotoTemplatesView = () => setCurrentView('templates');
+    const gotoTemplateView = (templateId) => setCurrentView('template', { id: templateId });
+    const handleClickInput = () => {
+        if (state.currentView) {
+            setCurrentView(null);
+        }
+    };
+    const toggleViewVisible = (e) => {
+        e.stopPropagation();
+        setCurrentView(state.currentView ? null : 'templates');
+    };
+    return (_jsx(ClickAwayListener, { onClickAway: () => reset(), mouseEvent: "onMouseUp", children: _jsxs(Box, { sx: { maxWidth: 440, fontSize: 14, zIndex: 1201 }, ...rest, children: [state.currentView === 'templates' && _jsx(Templates, { onSelect: (template) => gotoTemplateView(template.id) }), state.currentView === 'template' && (_jsx(Template, { template: state.currentTemplate, gotoTemplatesView: gotoTemplatesView })), state.currentView === 'output' && (_jsx(OutputView, { template: state.currentTemplate, gotoTemplatesView: gotoTemplatesView, gotoTemplateView: gotoTemplateView })), _jsxs(Box, { sx: { mt: 0.5 }, onClick: handleClickInput, children: [_jsx(Input, { prepend: _jsxs(Box, { onClick: toggleViewVisible, sx: {
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    flex: '0 0 auto',
+                                    gap: 0.5,
+                                    height: 26,
+                                    mr: 0.5,
+                                    px: 1.25,
+                                    fontSize: 13,
+                                    bgcolor: 'grey.200',
+                                    borderRadius: 3,
+                                    cursor: 'pointer',
+                                    '&:hover': {
+                                        color: 'primary.dark',
+                                        bgcolor: alpha(theme.palette.primary.light, 0.2),
+                                    },
+                                }, children: [_jsx(Box, { children: "Templates" }), _jsx(Box, { component: "i", className: "iconify", "data-icon": "mdi:chevron-down", "data-height": "16px" })] }) }), state.currentView === null && status === 'completed' && (_jsxs(Box, { children: [_jsx(Output, {}), _jsx(Menu, {})] }))] })] }) }));
+}

package/lib/ext/Aide/external-templates/parameter-field.d.ts

@@ -0,0 +1,6 @@
+import { TextFieldProps } from '@mui/material';
+import { Parameter } from '../types';
+export default function ParameterField({ parameter, ...props }: {
+    parameter: Parameter;
+    onChange: (value: string | number | undefined) => void;
+} & Omit<TextFieldProps, 'onChange'>): import("react/jsx-runtime").JSX.Element;

package/lib/ext/Aide/external-templates/parameter-field.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { TextField, MenuItem } from '@mui/material';
+export default function ParameterField({ parameter, ...props }) {
+    const Field = {
+        number: NumberParameterField,
+        string: StringParameterField,
+        select: SelectParameterField,
+        language: LanguageParameterField,
+    }[parameter.type || 'string'];
+    return _jsx(Field, { ...{ parameter }, ...props });
+}
+function StringParameterField({ parameter, onChange, ...props }) {
+    return (_jsx(TextField, { required: parameter.required, label: parameter.label, placeholder: parameter.placeholder, helperText: parameter.helper, multiline: parameter.multiline, minRows: parameter.multiline ? 2 : undefined, onChange: (e) => onChange(e.target.value), ...props, slotProps: {
+            htmlInput: { maxLength: parameter.maxLength },
+        } }));
+}
+function NumberParameterField({ parameter, ...props }) {
+    return (_jsx(NumberField, { required: parameter.required, label: parameter.label, placeholder: parameter.placeholder, helperText: parameter.helper, min: parameter.min, max: parameter.max, ...props }));
+}
+function SelectParameterField({ parameter, onChange, ...props }) {
+    return (_jsxs(TextField, { required: parameter.required, label: parameter.label, placeholder: parameter.placeholder, helperText: parameter.helper, select: true, 
+        // SelectProps={{ MenuProps: { keepMounted: false, disablePortal: false } }}
+        onChange: (e) => onChange(e.target.value), ...props, slotProps: {
+            select: {
+                MenuProps: { disablePortal: true },
+            },
+        }, children: [_jsx(MenuItem, { value: "", children: _jsx("em", { children: "None" }) }), (parameter.options ?? []).map((option) => (_jsx(MenuItem, { value: option.value, children: option.label }, option.id)))] }));
+}
+const languages = [
+    { en: 'English', cn: '英语' },
+    { en: 'Simplified Chinese', cn: '中文-简体' },
+    { en: 'Traditional Chinese', cn: '中文-繁体' },
+    { en: 'Spanish', cn: '西班牙语' },
+    { en: 'French', cn: '法语' },
+    { en: 'German', cn: '德语' },
+    { en: 'Italian', cn: '意大利语' },
+    { en: 'Portuguese', cn: '葡萄牙语' },
+    { en: 'Japanese', cn: '日语' },
+    { en: 'Korean', cn: '韩语' },
+    { en: 'Russian', cn: '俄语' },
+    { en: 'Polish', cn: '波兰语' },
+    { en: 'Arabic', cn: '阿拉伯语' },
+    { en: 'Dutch', cn: '荷兰语' },
+    { en: 'Swedish', cn: '瑞典语' },
+    { en: 'Finnish', cn: '芬兰语' },
+    { en: 'Czech', cn: '捷克语' },
+    { en: 'Danish', cn: '丹麦语' },
+    { en: 'Greek', cn: '希腊语' },
+    { en: 'Romanian', cn: '罗马尼亚语' },
+    { en: 'Hungarian', cn: '匈牙利语' },
+    { en: 'Bulgarian', cn: '保加利亚语' },
+    { en: 'Slovak', cn: '斯洛伐克语' },
+    { en: 'Norwegian', cn: '挪威语' },
+    { en: 'Hebrew', cn: '希伯来语' },
+    { en: 'Turkish', cn: '土耳其语' },
+    { en: 'Thai', cn: '泰语' },
+    { en: 'Indonesian', cn: '印尼语' },
+    { en: 'Vietnamese', cn: '越南语' },
+    { en: 'Hindi', cn: '印地语' },
+];
+function LanguageParameterField({ parameter, onChange, ...props }) {
+    return (_jsxs(TextField, { required: parameter.required, label: parameter.label, placeholder: parameter.placeholder, helperText: parameter.helper, select: true, onChange: (e) => onChange(e.target.value), ...props, children: [_jsx(MenuItem, { value: "", children: _jsx("em", { children: "None" }) }), languages.map((option) => (_jsx(MenuItem, { value: option.en, children: option.en }, option.en)))] }));
+}
+function NumberField({ min, max, default: def, onChange, ...props }) {
+    const correctValue = (e) => {
+        const value = e.target.value.trim();
+        if (!value) {
+            return def;
+        }
+        let num = Number(Number(value).toFixed(0));
+        if (!Number.isInteger(num)) {
+            return def;
+        }
+        if (typeof min === 'number') {
+            num = Math.max(min, num);
+        }
+        if (typeof max === 'number') {
+            num = Math.min(max, num);
+        }
+        return num;
+    };
+    return (_jsx(TextField, { onChange: (e) => onChange?.(correctValue(e)), ...props, slotProps: {
+            htmlInput: {
+                type: 'number',
+                inputMode: 'numeric',
+                pattern: '[0-9]*',
+                min,
+                max,
+                ...props.inputProps,
+            },
+        } }));
+}

package/lib/ext/Aide/hooks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 检查 ai 是否可用
+ * 注意: 该 hook 可适用于无法使用 useAideContext 的场景, 比如 editor toolbar button 中
+ */
+export declare function useAIAvailable(): {
+    available: boolean;
+};

package/lib/ext/Aide/hooks.js

@@ -0,0 +1,14 @@
+import { useRequest } from 'ahooks';
+import { useEditorConfig } from '../../config';
+/**
+ * 检查 ai 是否可用
+ * 注意: 该 hook 可适用于无法使用 useAideContext 的场景, 比如 editor toolbar button 中
+ */
+export function useAIAvailable() {
+    const { AI } = useEditorConfig();
+    const { data } = useRequest(async () => {
+        const available = await AI?.checkAvailable();
+        return available;
+    }, { cacheKey: 'editor-aide-available', staleTime: -1 });
+    return { available: !!data };
+}

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

@@ -0,0 +1,2 @@
+export * from './Aide';
+export * from './context';