@fastsprout/reacd-shadcn 0.0.0-stage → 0.2.0

package/dist/editor-conversion/from-sdk-block.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { EDITOR_SDK_BLOCK_TYPES } from '../editor-sdk/block-types.js';
+import { sdkAttribute } from './attribute.js';
+import { inlineContentFromSdk } from './from-sdk-inline.js';
+const blockType = z.enum(EDITOR_SDK_BLOCK_TYPES);
+export function sdkChildren(node, project) {
+    const children = [];
+    node.forEach((child) => {
+        children.push(project(child));
+    });
+    return children;
+}
+const projectors = {
+    paragraph(node, identify) {
+        return {
+            type: 'paragraph',
+            id: identify(node),
+            content: inlineContentFromSdk(node),
+        };
+    },
+    heading(node, identify) {
+        return {
+            type: 'heading',
+            id: identify(node),
+            level: sdkAttribute(node, 'level'),
+            content: inlineContentFromSdk(node),
+        };
+    },
+    blockquote(node, identify) {
+        return {
+            type: 'quote',
+            id: identify(node),
+            children: sdkChildren(node, (child) => blockFromSdk(child, identify)),
+        };
+    },
+    codeBlock(node, identify) {
+        const language = sdkAttribute(node, 'language');
+        return {
+            type: 'codeBlock',
+            id: identify(node),
+            text: node.textContent,
+            ...(language == null ? {} : { language }),
+        };
+    },
+    bulletList(node, identify) {
+        return {
+            type: 'bulletList',
+            id: identify(node),
+            items: sdkChildren(node, (child) => blockFromSdk(child, identify)),
+        };
+    },
+    orderedList(node, identify) {
+        return {
+            type: 'orderedList',
+            id: identify(node),
+            start: sdkAttribute(node, 'start'),
+            items: sdkChildren(node, (child) => blockFromSdk(child, identify)),
+        };
+    },
+    listItem(node, identify) {
+        return {
+            type: 'listItem',
+            id: identify(node),
+            children: sdkChildren(node, (child) => blockFromSdk(child, identify)),
+        };
+    },
+    horizontalRule(node, identify) {
+        return { type: 'separator', id: identify(node) };
+    },
+};
+export function blockFromSdk(node, identify) {
+    return projectors[blockType.parse(node.type.name)](node, identify);
+}

package/dist/editor-conversion/from-sdk-inline.d.ts

@@ -0,0 +1,3 @@
+import type { Node } from '@tiptap/pm/model';
+export declare function inlineFromSdk(node: Node): unknown[];
+export declare function inlineContentFromSdk(node: Node): unknown[];

package/dist/editor-conversion/from-sdk-inline.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { EDITOR_MARKS } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { sdkAttribute } from './attribute.js';
+import { editorTextChunks } from './text-chunks.js';
+const inlineType = z.enum(['text', 'hardBreak', 'reacdMention', 'reacdEmoji']);
+const markType = z.enum([...EDITOR_MARKS, 'link']);
+const projectors = {
+    text(node) {
+        const marks = [];
+        let link;
+        for (const mark of node.marks) {
+            const type = markType.parse(mark.type.name);
+            if (type === 'link')
+                link = sdkAttribute(mark, 'href');
+            else
+                marks.push(type);
+        }
+        const text = z.string().parse(node.text);
+        return [...editorTextChunks(text)].map(({ from, to }) => ({
+            type: 'text',
+            text: text.slice(from, to),
+            ...(marks.length === 0 ? {} : { marks: [...marks] }),
+            ...(link === undefined ? {} : { link }),
+        }));
+    },
+    hardBreak() {
+        return [{ type: 'hardBreak' }];
+    },
+    reacdMention(node) {
+        return [
+            {
+                type: 'mention',
+                id: sdkAttribute(node, 'id'),
+                label: sdkAttribute(node, 'label'),
+            },
+        ];
+    },
+    reacdEmoji(node) {
+        return [
+            {
+                type: 'emoji',
+                name: sdkAttribute(node, 'name'),
+                value: sdkAttribute(node, 'value'),
+            },
+        ];
+    },
+};
+export function inlineFromSdk(node) {
+    return projectors[inlineType.parse(node.type.name)](node);
+}
+export function inlineContentFromSdk(node) {
+    const content = [];
+    node.forEach((child) => {
+        content.push(...inlineFromSdk(child));
+    });
+    return content;
+}

package/dist/editor-conversion/from-sdk.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from '@tiptap/pm/model';
+import type { EditorDocument } from '@fastsprout/reacd/adapter-runtime/core/editor-document.js';
+import type { Result } from '@fastsprout/reacd/adapter-runtime/core/result.js';
+export declare function editorDocumentFromSdk(document: Node): Result<EditorDocument>;

package/dist/editor-conversion/from-sdk.js

@@ -0,0 +1,35 @@
+import { EDITOR_ERRORS, EDITOR_POLICY, } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { editorDocumentSchema } from '@fastsprout/reacd/adapter-runtime/schema/editor/document/index.js';
+import { boundedSdkDocument } from './budget.js';
+import { blockFromSdk, sdkChildren } from './from-sdk-block.js';
+import { createSdkIdAllocator } from './id-allocator.js';
+function failure() {
+    return {
+        success: false,
+        issues: [{ path: 'Editor.value', message: EDITOR_ERRORS.projection }],
+    };
+}
+export function editorDocumentFromSdk(document) {
+    if (!boundedSdkDocument(document))
+        return failure();
+    try {
+        document.check();
+        const identify = createSdkIdAllocator(document);
+        const parsed = editorDocumentSchema.safeParse({
+            version: EDITOR_POLICY.version,
+            blocks: sdkChildren(document, (node) => blockFromSdk(node, identify)),
+        });
+        return parsed.success
+            ? { success: true, data: parsed.data }
+            : {
+                success: false,
+                issues: parsed.error.issues.map((issue) => ({
+                    path: ['Editor', 'value', ...issue.path].map(String).join('.'),
+                    message: issue.message,
+                })),
+            };
+    }
+    catch {
+        return failure();
+    }
+}

package/dist/editor-conversion/id-allocator.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from '@tiptap/pm/model';
+export declare function createSdkIdAllocator(document: Node): (node: Node) => string;

package/dist/editor-conversion/id-allocator.js

@@ -0,0 +1,29 @@
+import { EDITOR_POLICY } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { stateKeySchema } from '@fastsprout/reacd/adapter-runtime/schema/state/shared/definition.js';
+import { EDITOR_SDK_BLOCK_TYPES } from '../editor-sdk/block-types.js';
+import { sdkAttribute } from './attribute.js';
+const BLOCKS = new Set(EDITOR_SDK_BLOCK_TYPES);
+const identitySchema = stateKeySchema.nullish();
+export function createSdkIdAllocator(document) {
+    const used = new Set();
+    document.descendants((node) => {
+        if (!BLOCKS.has(node.type.name))
+            return;
+        const id = identitySchema.parse(sdkAttribute(node, 'reacdId'));
+        if (id != null)
+            used.add(id);
+    });
+    let ordinal = 0;
+    return (node) => {
+        const current = identitySchema.parse(sdkAttribute(node, 'reacdId'));
+        if (current != null)
+            return current;
+        let id;
+        do {
+            ordinal += 1;
+            id = `${EDITOR_POLICY.blockIdPrefix}-${ordinal}`;
+        } while (used.has(id));
+        used.add(id);
+        return id;
+    };
+}

package/dist/editor-conversion/projection-weight.d.ts

@@ -0,0 +1,8 @@
+import type { Node } from '@tiptap/pm/model';
+interface Weight {
+    values: number;
+    characters: number;
+    extraDepth: number;
+}
+export declare function sdkProjectionWeight(node: Node, inCode: boolean): Weight;
+export {};

package/dist/editor-conversion/projection-weight.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { EDITOR_MARKS, EDITOR_POLICY, } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { CONTENT_POLICY } from '@fastsprout/reacd/adapter-runtime/core/policy.js';
+import { linkSchema } from '@fastsprout/reacd/adapter-runtime/schema/link/link.schema.js';
+import { stateKeySchema } from '@fastsprout/reacd/adapter-runtime/schema/state/shared/definition.js';
+import { editorTextChunks } from './text-chunks.js';
+const markSchema = z.enum(EDITOR_MARKS);
+const optionalId = stateKeySchema.nullish();
+function attribute(node, key) {
+    return node.attrs[key];
+}
+function textAttribute(node, key) {
+    return z.string().parse(attribute(node, key));
+}
+function identity(node) {
+    const parsed = optionalId.parse(attribute(node, 'reacdId'));
+    return parsed ?? `${EDITOR_POLICY.blockIdPrefix}-${EDITOR_POLICY.maxBlocks}`;
+}
+function fieldsWeight(fields) {
+    const entries = Object.entries(fields);
+    return {
+        values: entries.length + 1,
+        characters: entries.reduce((size, [key, value]) => size + key.length + (typeof value === 'string' ? value.length : 0), 0),
+        extraDepth: 1,
+    };
+}
+export function sdkProjectionWeight(node, inCode) {
+    const type = node.type.name;
+    if (inCode) {
+        if (type !== 'text')
+            throw new Error('Invalid code child.');
+        const text = z.string().max(EDITOR_POLICY.maxTextLength).parse(node.text);
+        return { values: 0, characters: text.length, extraDepth: 0 };
+    }
+    switch (type) {
+        case 'doc':
+            return fieldsWeight({ version: EDITOR_POLICY.version, blocks: null });
+        case 'paragraph':
+            return fieldsWeight({ type, id: identity(node), content: null });
+        case 'heading':
+            return fieldsWeight({
+                type,
+                id: identity(node),
+                content: null,
+                level: z.number().parse(attribute(node, 'level')),
+            });
+        case 'blockquote':
+            return fieldsWeight({ type: 'quote', id: identity(node), children: null });
+        case 'bulletList':
+            return fieldsWeight({ type, id: identity(node), items: null });
+        case 'orderedList':
+            return fieldsWeight({
+                type,
+                id: identity(node),
+                items: null,
+                start: z.number().parse(attribute(node, 'start')),
+            });
+        case 'listItem':
+            return fieldsWeight({ type, id: identity(node), children: null });
+        case 'horizontalRule':
+            return fieldsWeight({ type: 'separator', id: identity(node) });
+        case 'codeBlock': {
+            const language = z.string().nullish().parse(attribute(node, 'language'));
+            return fieldsWeight({
+                type,
+                id: identity(node),
+                text: '',
+                ...(language == null ? {} : { language }),
+            });
+        }
+        case 'hardBreak':
+            return fieldsWeight({ type });
+        case 'reacdMention':
+            return fieldsWeight({
+                type: 'mention',
+                id: textAttribute(node, 'id'),
+                label: textAttribute(node, 'label'),
+            });
+        case 'reacdEmoji':
+            return fieldsWeight({
+                type: 'emoji',
+                name: textAttribute(node, 'name'),
+                value: textAttribute(node, 'value'),
+            });
+        case 'text': {
+            const text = z.string().min(1).max(EDITOR_POLICY.maxCharacters).parse(node.text);
+            const result = fieldsWeight({ type, text: '' });
+            let marks = 0;
+            for (const mark of node.marks) {
+                if (mark.type.name === 'link') {
+                    const target = mark.attrs['href'];
+                    if (typeof target !== 'string' ||
+                        target.length > CONTENT_POLICY.maxLinkLength)
+                        throw new Error('Invalid editor link.');
+                    const href = linkSchema.shape.href.parse(target);
+                    result.values += 1;
+                    result.characters += 'link'.length + href.length;
+                }
+                else {
+                    const name = markSchema.parse(mark.type.name);
+                    marks += 1;
+                    result.values += 1;
+                    result.characters += name.length;
+                }
+            }
+            if (marks > 0) {
+                result.values += 1;
+                result.characters += 'marks'.length;
+                result.extraDepth = 2;
+            }
+            let chunks = 0;
+            let characters = 0;
+            for (const chunk of editorTextChunks(text)) {
+                chunks += 1;
+                characters += chunk.to - chunk.from;
+            }
+            result.values *= chunks;
+            result.characters = result.characters * chunks + characters;
+            return result;
+        }
+        default:
+            throw new Error('Unsupported editor node.');
+    }
+}

package/dist/editor-conversion/text-chunks.d.ts

@@ -0,0 +1,6 @@
+interface TextChunk {
+    readonly from: number;
+    readonly to: number;
+}
+export declare function editorTextChunks(text: string): Generator<TextChunk>;
+export {};

package/dist/editor-conversion/text-chunks.js

@@ -0,0 +1,18 @@
+import { EDITOR_POLICY, EDITOR_UNICODE, } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+export function* editorTextChunks(text) {
+    let from = 0;
+    while (from < text.length) {
+        let to = Math.min(from + EDITOR_POLICY.maxTextLength, text.length);
+        if (to < text.length) {
+            const previous = text.charCodeAt(to - 1);
+            const next = text.charCodeAt(to);
+            if (previous >= EDITOR_UNICODE.highSurrogateMin &&
+                previous <= EDITOR_UNICODE.highSurrogateMax &&
+                next >= EDITOR_UNICODE.lowSurrogateMin &&
+                next <= EDITOR_UNICODE.lowSurrogateMax)
+                to -= 1;
+        }
+        yield { from, to };
+        from = to;
+    }
+}

package/dist/editor-conversion/to-sdk.d.ts

@@ -0,0 +1,3 @@
+import type { JSONContent } from '@tiptap/core';
+import type { EditorDocument } from '@fastsprout/reacd/adapter-runtime/core/editor-document.js';
+export declare function editorDocumentToSdk(document: EditorDocument): JSONContent;

package/dist/editor-conversion/to-sdk.js

@@ -0,0 +1,58 @@
+function inlineToSdk(inline) {
+    if (inline.type === 'hardBreak')
+        return { type: 'hardBreak' };
+    if (inline.type === 'mention')
+        return { type: 'reacdMention', attrs: { id: inline.id, label: inline.label } };
+    if (inline.type === 'emoji')
+        return { type: 'reacdEmoji', attrs: { name: inline.name, value: inline.value } };
+    const marks = (inline.marks ?? []).map((mark) => ({
+        type: mark,
+    }));
+    if (inline.link !== undefined)
+        marks.push({ type: 'link', attrs: { href: inline.link } });
+    return { type: 'text', text: inline.text, ...(marks.length === 0 ? {} : { marks }) };
+}
+function itemToSdk(item) {
+    return {
+        type: 'listItem',
+        attrs: { reacdId: item.id },
+        content: item.children.map(blockToSdk),
+    };
+}
+function blockToSdk(block) {
+    const attrs = { reacdId: block.id };
+    switch (block.type) {
+        case 'paragraph':
+            return { type: 'paragraph', attrs, content: block.content.map(inlineToSdk) };
+        case 'heading':
+            return {
+                type: 'heading',
+                attrs: { ...attrs, level: block.level },
+                content: block.content.map(inlineToSdk),
+            };
+        case 'quote':
+            return { type: 'blockquote', attrs, content: block.children.map(blockToSdk) };
+        case 'codeBlock':
+            return {
+                type: 'codeBlock',
+                attrs: {
+                    ...attrs,
+                    ...(block.language === undefined ? {} : { language: block.language }),
+                },
+                content: block.text.length === 0 ? [] : [{ type: 'text', text: block.text }],
+            };
+        case 'bulletList':
+            return { type: 'bulletList', attrs, content: block.items.map(itemToSdk) };
+        case 'orderedList':
+            return {
+                type: 'orderedList',
+                attrs: { ...attrs, start: block.start },
+                content: block.items.map(itemToSdk),
+            };
+        case 'separator':
+            return { type: 'horizontalRule', attrs };
+    }
+}
+export function editorDocumentToSdk(document) {
+    return { type: 'doc', content: document.blocks.map(blockToSdk) };
+}

package/dist/editor-drag-handle/editor-drag-handle.adapter.d.ts

@@ -0,0 +1,2 @@
+import type * as Handle from '@fastsprout/reacd/adapter-runtime/components/editor-drag-handle/index.js';
+export declare function ShadcnEditorDragHandle({ label, blockId, disabled, }: Handle.EditorDragHandleProps): import("react").JSX.Element;

package/dist/editor-drag-handle/editor-drag-handle.adapter.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useId } from 'react';
+import { editorBlockIds } from '@fastsprout/reacd/adapter-runtime/core/editor-blocks.js';
+import { EDITOR_DRAG_POLICY as P } from '@fastsprout/reacd/adapter-runtime/core/editor-drag-handle-policy.js';
+import { EditorScopeContext } from '@fastsprout/reacd/adapter-runtime/renderer/editor/editor-context.js';
+import { Issues } from '@fastsprout/reacd/adapter-runtime/renderer/issues/issues.renderer.js';
+import { Button } from '../vendor/ui/button.js';
+import { useDragSession } from './use-drag-session.js';
+function issue(message) {
+    return _jsx(Issues, { issues: [{ path: 'EditorDragHandle', message }] });
+}
+export function ShadcnEditorDragHandle({ label, blockId, disabled, }) {
+    const id = useId();
+    const port = useContext(EditorScopeContext);
+    const target = blockId ?? port?.selectedBlockId;
+    const known = port !== null &&
+        target !== undefined &&
+        editorBlockIds(port.document).includes(target);
+    const blocked = disabled === true || port === null || port.disabled || !known;
+    const session = useDragSession(target, blocked);
+    if (port === null)
+        return issue(P.scopeError);
+    if (target === undefined)
+        return issue(P.selectionError);
+    if (!known)
+        return issue(P.unknownError);
+    const moves = port.blockMoves(target);
+    const canDrag = !blocked && (moves.up || moves.down);
+    const selectLabel = canDrag ? P.selectAndDrag : P.select;
+    return (_jsxs("div", { className: "reacd-node reacd-editor-drag-handle", role: "group", "aria-labelledby": `${id}-label`, "aria-describedby": `${id}-help`, "aria-disabled": blocked || undefined, children: [_jsx("p", { id: `${id}-label`, children: label }), _jsx("p", { id: `${id}-help`, children: blocked
+                    ? P.protectedInstructions
+                    : canDrag
+                        ? P.instructions
+                        : P.fixedInstructions }), _jsxs("div", { className: "reacd-editor-drag-controls", children: [_jsx(Button, { type: "button", className: "reacd-button", variant: "outline", disabled: blocked, draggable: canDrag, "aria-label": `${label}: ${selectLabel}`, onClick: () => port.selectBlock(target), onDragStart: (event) => {
+                            session.finish();
+                            if (!canDrag || !port.beginBlockDrag(target)) {
+                                event.preventDefault();
+                                return;
+                            }
+                            session.start({ id: target, cancel: () => port.cancelBlockDrag() });
+                            try {
+                                event.dataTransfer.effectAllowed = P.moveEffect;
+                                event.dataTransfer.setData(P.mimeType, target);
+                            }
+                            catch {
+                                session.finish();
+                                event.preventDefault();
+                            }
+                        }, onDragEnd: () => session.finish(), onKeyDown: (event) => {
+                            if (event.key === 'Escape' && session.finish()) {
+                                event.preventDefault();
+                            }
+                        }, children: selectLabel }), _jsx(Button, { type: "button", className: "reacd-button", variant: "outline", disabled: blocked || !moves.up, "aria-label": `${label}: ${P.up}`, onClick: () => port.moveBlock(target, 'up'), children: P.up }), _jsx(Button, { type: "button", className: "reacd-button", variant: "outline", disabled: blocked || !moves.down, "aria-label": `${label}: ${P.down}`, onClick: () => port.moveBlock(target, 'down'), children: P.down })] })] }));
+}

package/dist/editor-drag-handle/use-drag-session.d.ts

@@ -0,0 +1,9 @@
+interface DragOwner {
+    readonly id: string;
+    readonly cancel: () => void;
+}
+export declare function useDragSession(id: string | undefined, blocked: boolean): {
+    start: (session: DragOwner) => void;
+    finish: () => boolean;
+};
+export {};

package/dist/editor-drag-handle/use-drag-session.js

@@ -0,0 +1,22 @@
+import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
+export function useDragSession(id, blocked) {
+    const owner = useRef(null);
+    const finish = useCallback(() => {
+        const previous = owner.current;
+        owner.current = null;
+        previous?.cancel();
+        return previous !== null;
+    }, []);
+    useEffect(() => () => {
+        finish();
+    }, [finish]);
+    useLayoutEffect(() => {
+        if (owner.current && (owner.current.id !== id || blocked))
+            finish();
+    }, [id, blocked, finish]);
+    function start(session) {
+        finish();
+        owner.current = session;
+    }
+    return { start, finish };
+}

package/dist/editor-emoji-menu/editor-emoji-menu.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { EditorEmojiMenuProps } from '@fastsprout/reacd/adapter-runtime/components/editor-emoji-menu/index.js';
+export declare function ShadcnEditorEmojiMenu(properties: EditorEmojiMenuProps): import("react").JSX.Element;

package/dist/editor-emoji-menu/editor-emoji-menu.adapter.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useEditorMenu } from '../editor-menu/use-editor-menu.js';
+import { EditorMenuPanel } from '../editor-menu/menu-panel.js';
+export function ShadcnEditorEmojiMenu(properties) {
+    const items = useMemo(() => properties.items.map((item) => ({ ...item, kind: 'emoji' })), [properties.items]);
+    const menu = useEditorMenu('emoji', items, properties.disabled);
+    return _jsx(EditorMenuPanel, { label: properties.label, ...menu });
+}

package/dist/editor-mention-menu/editor-mention-menu.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { EditorMentionMenuProps } from '@fastsprout/reacd/adapter-runtime/components/editor-mention-menu/index.js';
+export declare function ShadcnEditorMentionMenu(properties: EditorMentionMenuProps): import("react").JSX.Element;

package/dist/editor-mention-menu/editor-mention-menu.adapter.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useEditorMenu } from '../editor-menu/use-editor-menu.js';
+import { EditorMenuPanel } from '../editor-menu/menu-panel.js';
+const EMPTY = Object.freeze([]);
+export function ShadcnEditorMentionMenu(properties) {
+    const catalog = properties.items ?? EMPTY;
+    const items = useMemo(() => catalog.map((item) => ({ ...item, kind: 'mention' })), [catalog]);
+    const lookup = useMemo(() => properties.onQueryChange === undefined
+        ? undefined
+        : {
+            results: properties.results,
+            onQueryChange: properties.onQueryChange,
+        }, [properties.results, properties.onQueryChange]);
+    const menu = useEditorMenu('mention', items, properties.disabled, lookup);
+    return _jsx(EditorMenuPanel, { label: properties.label, ...menu });
+}

package/dist/editor-menu/lookup-controller.d.ts

@@ -0,0 +1,24 @@
+import type { EditorMentionLookupRequest, EditorMentionLookupResult } from '@fastsprout/reacd/adapter-runtime/schema/editor-mention-menu/lookup.schema.js';
+import type * as mention from '@fastsprout/reacd/adapter-runtime/schema/editor-mention-menu/item.schema.js';
+export interface EditorMentionLookupView {
+    readonly request: EditorMentionLookupRequest | undefined;
+    readonly status: 'loading' | 'ready' | 'error';
+    readonly items: readonly mention.EditorMentionItem[];
+    readonly error: string | undefined;
+}
+export interface EditorMentionLookupState {
+    readonly scope: string;
+    readonly ordinal: bigint;
+    readonly current: EditorMentionLookupRequest | undefined;
+    readonly accepted: EditorMentionLookupResult | undefined;
+}
+interface LookupTransition {
+    readonly state: EditorMentionLookupState;
+    readonly view: EditorMentionLookupView;
+}
+export declare function advanceMentionLookup(state: EditorMentionLookupState, query: string, result: EditorMentionLookupResult | null): LookupTransition;
+export declare function createMentionLookupController(scope: string): {
+    close(): void;
+    update(query: string, result: EditorMentionLookupResult | null): EditorMentionLookupView;
+};
+export {};