@peers-app/peers-ui 0.0.14

package/dist/components/main-content-container.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainContentContainer = void 0;
+const react_1 = __importStar(require("react"));
+const react_split_pane_1 = __importDefault(require("react-split-pane"));
+const globals_1 = require("../globals");
+const thread_view_1 = require("./messages/thread-view");
+const router_1 = require("./router");
+const hooks_1 = require("../hooks");
+const MainContentContainer = () => {
+    const splitPositionGlobalName = 'mainContentContainerSplitPos';
+    let [splitPos, setSplitPos] = (0, react_1.useState)(localStorage.getItem(splitPositionGlobalName) || '800');
+    (0, hooks_1.useObservable)(globals_1.threadViewOpen);
+    if (!(0, globals_1.threadViewOpen)()) {
+        return (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement("button", { className: "btn small m-0 p-0 thread-view-open-button", onClick: () => {
+                    const lastThread = (0, globals_1.openThreads)()[0];
+                    if (!lastThread) {
+                        (0, thread_view_1.startNewThread)();
+                    }
+                    else {
+                        (0, globals_1.threadViewOpen)(true);
+                    }
+                }, style: {
+                    position: 'fixed',
+                    // top: '3px',
+                    // right: '16px',
+                    top: '-5px',
+                    right: '6px',
+                    zIndex: 1000,
+                    // backgroundColor: 'white',  
+                    backgroundColor: 'transparent'
+                } }, "+"),
+            react_1.default.createElement(router_1.Router, null)));
+    }
+    return (
+    // @ts-ignore
+    react_1.default.createElement(react_split_pane_1.default, { split: "vertical", defaultSize: parseInt(splitPos), onChange: (size) => {
+            localStorage.setItem(splitPositionGlobalName, String(size));
+            setSplitPos(String(size));
+        }, style: {
+            position: 'unset',
+            height: `100vh`,
+        } },
+        react_1.default.createElement("div", null,
+            react_1.default.createElement(router_1.Router, null)),
+        react_1.default.createElement("div", { className: 'thread-view', style: {
+                height: `100vh`,
+                overflowY: 'scroll',
+                width: `calc(100vw - ${splitPos}px - 300px)`,
+            } },
+            react_1.default.createElement(thread_view_1.ThreadContainer, null))));
+};
+exports.MainContentContainer = MainContentContainer;

package/dist/components/markdown-editor/autolink-plugin.d.ts

@@ -0,0 +1,2 @@
+export declare function LexicalAutoLinkPlugin(): JSX.Element;
+export default function LinkPlugin(): JSX.Element;

package/dist/components/markdown-editor/autolink-plugin.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexicalAutoLinkPlugin = LexicalAutoLinkPlugin;
+exports.default = LinkPlugin;
+const react_1 = __importDefault(require("react"));
+const LexicalAutoLinkPlugin_1 = require("@lexical/react/LexicalAutoLinkPlugin");
+const URL_REGEX = /((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)(?<![-.+():%])/;
+const EMAIL_REGEX = /(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))/;
+const MATCHERS = [
+    (0, LexicalAutoLinkPlugin_1.createLinkMatcherWithRegExp)(URL_REGEX, (text) => {
+        return text.startsWith('http') ? text : `https://${text}`;
+    }),
+    (0, LexicalAutoLinkPlugin_1.createLinkMatcherWithRegExp)(EMAIL_REGEX, (text) => {
+        return `mailto:${text}`;
+    }),
+];
+function LexicalAutoLinkPlugin() {
+    return react_1.default.createElement(LexicalAutoLinkPlugin_1.AutoLinkPlugin, { matchers: MATCHERS });
+}
+const LexicalLinkPlugin_1 = require("@lexical/react/LexicalLinkPlugin");
+function LinkPlugin() {
+    const validateUrl = (url) => {
+        return url.startsWith('http://') || url.startsWith('https://') || url.startsWith('mailto:');
+    };
+    return react_1.default.createElement(LexicalLinkPlugin_1.LinkPlugin, { validateUrl: validateUrl });
+}

package/dist/components/markdown-editor/editor-inline.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { IMarkdownEditorProps } from "./editor";
+export declare const MarkdownEditorInline: (props: IMarkdownEditorProps) => React.JSX.Element;

package/dist/components/markdown-editor/editor-inline.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownEditorInline = void 0;
+const react_1 = __importDefault(require("react"));
+const editor_1 = require("./editor");
+const MarkdownEditorInline = (props) => {
+    return (react_1.default.createElement("div", { className: "border rounded border-dark-subtle" },
+        react_1.default.createElement(editor_1.MarkdownEditor, { ...props })));
+};
+exports.MarkdownEditorInline = MarkdownEditorInline;

package/dist/components/markdown-editor/editor.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from "@peers-app/peers-sdk";
+import React from 'react';
+import { IToolbarControl } from './toolbar';
+import { IMentionConfig } from '../../mention-configs';
+export interface IEditorEffects {
+    onKeyDown?: (e: React.KeyboardEvent) => (boolean | void);
+    focus?: () => void;
+}
+export interface IMarkdownEditorProps {
+    value: Observable<string>;
+    effects?: IEditorEffects;
+    topRightControls?: IToolbarControl[];
+    autoFocus?: boolean;
+    hideToolbar?: boolean;
+    maxHeight?: string | number;
+    mentionConfigs?: IMentionConfig[];
+}
+export declare function MarkdownEditor(props: IMarkdownEditorProps): React.JSX.Element;

package/dist/components/markdown-editor/editor.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownEditor = MarkdownEditor;
+const code_1 = require("@lexical/code");
+const link_1 = require("@lexical/link");
+const list_1 = require("@lexical/list");
+const LexicalAutoFocusPlugin_1 = require("@lexical/react/LexicalAutoFocusPlugin");
+const LexicalCheckListPlugin_1 = require("@lexical/react/LexicalCheckListPlugin");
+const LexicalComposer_1 = require("@lexical/react/LexicalComposer");
+const LexicalContentEditable_1 = require("@lexical/react/LexicalContentEditable");
+const LexicalErrorBoundary_1 = require("@lexical/react/LexicalErrorBoundary");
+const LexicalHistoryPlugin_1 = require("@lexical/react/LexicalHistoryPlugin");
+const LexicalListPlugin_1 = require("@lexical/react/LexicalListPlugin");
+const LexicalMarkdownShortcutPlugin_1 = require("@lexical/react/LexicalMarkdownShortcutPlugin");
+const LexicalRichTextPlugin_1 = require("@lexical/react/LexicalRichTextPlugin");
+const LexicalTabIndentationPlugin_1 = require("@lexical/react/LexicalTabIndentationPlugin");
+const rich_text_1 = require("@lexical/rich-text");
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const react_1 = __importStar(require("react"));
+const autolink_plugin_1 = require("./autolink-plugin");
+const markdown_plugin_1 = require("./markdown-plugin");
+const mention_node_1 = require("./mention-node");
+const mentions_plugin_1 = require("./mentions-plugin");
+const theme_1 = __importDefault(require("./theme"));
+const toolbar_1 = require("./toolbar");
+const lexical_1 = require("lexical");
+const LexicalComposerContext_1 = require("@lexical/react/LexicalComposerContext");
+const mention_configs_1 = require("../../mention-configs");
+const editorConfig = {
+    namespace: 'PeersEditor',
+    nodes: [
+        rich_text_1.HeadingNode,
+        rich_text_1.QuoteNode,
+        code_1.CodeNode,
+        list_1.ListNode,
+        list_1.ListItemNode,
+        mention_node_1.MentionNode,
+        link_1.AutoLinkNode,
+        link_1.LinkNode,
+    ],
+    // Handling of errors during update
+    onError(error) {
+        throw error;
+    },
+    // The editor theme
+    theme: theme_1.default,
+};
+function MarkdownEditor(props) {
+    const { effects } = props;
+    const editorRef = react_1.default.useRef(null);
+    const [mentionsOpen] = (0, react_1.useState)(() => {
+        const obs = (0, peers_sdk_1.observable)(false);
+        return obs;
+    });
+    if (effects) {
+        effects.focus = () => {
+            if (editorRef.current?.children[0]) {
+                const div = editorRef.current.children[0];
+                setTimeout(() => {
+                    div.focus();
+                    // Set the selection to the end of the div content
+                    const range = document.createRange();
+                    range.selectNodeContents(div);
+                    range.collapse(false);
+                    const selection = window.getSelection();
+                    if (selection) {
+                        selection.removeAllRanges();
+                        selection.addRange(range);
+                    }
+                }, 10);
+            }
+        };
+    }
+    const _mentionConfigs = props.mentionConfigs ?? mention_configs_1.mentionConfigs;
+    return (react_1.default.createElement(LexicalComposer_1.LexicalComposer, { initialConfig: { ...editorConfig } },
+        react_1.default.createElement("div", { className: "editor-container" },
+            props.hideToolbar ? null : react_1.default.createElement(toolbar_1.ToolbarPlugin, { topRightControls: props.topRightControls }),
+            react_1.default.createElement("div", { className: "editor-inner", ref: editorRef, style: { maxHeight: props.maxHeight, overflowY: 'auto' } },
+                react_1.default.createElement(LexicalRichTextPlugin_1.RichTextPlugin, { contentEditable: react_1.default.createElement(LexicalContentEditable_1.ContentEditable, { className: "editor-input p-2" }), placeholder: null, ErrorBoundary: LexicalErrorBoundary_1.LexicalErrorBoundary }),
+                react_1.default.createElement(LexicalHistoryPlugin_1.HistoryPlugin, null),
+                props.autoFocus && react_1.default.createElement(LexicalAutoFocusPlugin_1.AutoFocusPlugin, { defaultSelection: 'rootEnd' }),
+                react_1.default.createElement(LexicalListPlugin_1.ListPlugin, null),
+                _mentionConfigs.length > 0 && (react_1.default.createElement(mentions_plugin_1.MentionsPlugin, { mentionConfigs: _mentionConfigs, mentionsOpen: mentionsOpen })),
+                react_1.default.createElement(autolink_plugin_1.LexicalAutoLinkPlugin, null),
+                react_1.default.createElement(markdown_plugin_1.MarkdownPlugin, { markdownObs: props.value }),
+                react_1.default.createElement(LexicalMarkdownShortcutPlugin_1.MarkdownShortcutPlugin, { transformers: markdown_plugin_1.customMarkdownTransformers }),
+                react_1.default.createElement(LexicalCheckListPlugin_1.CheckListPlugin, null),
+                react_1.default.createElement(LexicalTabIndentationPlugin_1.TabIndentationPlugin, null),
+                react_1.default.createElement(OnKeyDownPlugin, { effects: props.effects, mentionsOpen: mentionsOpen })))));
+}
+const OnKeyDownPlugin = (props) => {
+    const [editor] = (0, LexicalComposerContext_1.useLexicalComposerContext)();
+    (0, react_1.useEffect)(() => {
+        const removeListener = editor.registerCommand(lexical_1.KEY_DOWN_COMMAND, (event) => {
+            if (props.mentionsOpen()) {
+                return false;
+            }
+            if (props.effects?.onKeyDown) {
+                const result = props.effects.onKeyDown(event);
+                return !!result;
+            }
+            return false;
+        }, lexical_1.COMMAND_PRIORITY_LOW);
+        return removeListener;
+    }, [editor]);
+    return null;
+};

package/dist/components/markdown-editor/markdown-plugin.d.ts

@@ -0,0 +1,9 @@
+import { ElementTransformer } from "@lexical/markdown";
+import { Observable } from "@peers-app/peers-sdk";
+export declare const PRESERVE_NEWLINES: ElementTransformer;
+export declare const customMarkdownTransformers: import("@lexical/markdown").Transformer[];
+interface IProps {
+    markdownObs: Observable<string>;
+}
+export declare function MarkdownPlugin(props: IProps): null;
+export {};

package/dist/components/markdown-editor/markdown-plugin.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customMarkdownTransformers = exports.PRESERVE_NEWLINES = void 0;
+exports.MarkdownPlugin = MarkdownPlugin;
+const list_1 = require("@lexical/list");
+const markdown_1 = require("@lexical/markdown");
+const LexicalComposerContext_1 = require("@lexical/react/LexicalComposerContext");
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const lexical_1 = require("lexical");
+const react_1 = require("react");
+const mention_node_1 = require("./mention-node");
+// Amount of spaces that define indentation level
+const LIST_INDENT_SIZE = 4;
+function getIndent(whitespaces) {
+    const tabs = whitespaces.match(/\t/g);
+    const spaces = whitespaces.match(/ /g);
+    let indent = 0;
+    if (tabs) {
+        indent += tabs.length;
+    }
+    if (spaces) {
+        indent += Math.floor(spaces.length / LIST_INDENT_SIZE);
+    }
+    return indent;
+}
+const listReplace = (listType) => {
+    return (parentNode, children, match) => {
+        const previousNode = parentNode.getPreviousSibling();
+        const nextNode = parentNode.getNextSibling();
+        const listItem = (0, list_1.$createListItemNode)(listType === 'check' ? match[3] === 'x' : undefined);
+        if ((0, list_1.$isListNode)(nextNode) && nextNode.getListType() === listType) {
+            const firstChild = nextNode.getFirstChild();
+            if (firstChild !== null) {
+                firstChild.insertBefore(listItem);
+            }
+            else {
+                // should never happen, but let's handle gracefully, just in case.
+                nextNode.append(listItem);
+            }
+            parentNode.remove();
+        }
+        else if ((0, list_1.$isListNode)(previousNode) &&
+            previousNode.getListType() === listType) {
+            previousNode.append(listItem);
+            parentNode.remove();
+        }
+        else {
+            const list = (0, list_1.$createListNode)(listType, listType === 'number' ? Number(match[2]) : undefined);
+            list.append(listItem);
+            parentNode.replace(list);
+        }
+        listItem.append(...children);
+        listItem.select(0, 0);
+        const indent = getIndent(match[1]);
+        if (indent) {
+            listItem.setIndent(indent);
+        }
+    };
+};
+const listExport = (listNode, exportChildren, depth) => {
+    const output = [];
+    const children = listNode.getChildren();
+    let index = 0;
+    for (const listItemNode of children) {
+        if ((0, list_1.$isListItemNode)(listItemNode)) {
+            if (listItemNode.getChildrenSize() === 1) {
+                const firstChild = listItemNode.getFirstChild();
+                if ((0, list_1.$isListNode)(firstChild)) {
+                    output.push(listExport(firstChild, exportChildren, depth + 1));
+                    continue;
+                }
+            }
+            const indent = ' '.repeat(depth * LIST_INDENT_SIZE);
+            const listType = listNode.getListType();
+            const prefix = listType === 'number'
+                ? `${listNode.getStart() + index}. `
+                : listType === 'check'
+                    ? `- [${listItemNode.getChecked() ? 'x' : ' '}] `
+                    : '- ';
+            output.push(indent + prefix + exportChildren(listItemNode));
+            index++;
+        }
+    }
+    return output.join('\n');
+};
+const CHECK_LIST_TRANSFORMER = {
+    dependencies: [list_1.ListNode, list_1.ListItemNode],
+    export: (node, exportChildren) => {
+        return (0, list_1.$isListNode)(node) ? listExport(node, exportChildren, 0) : null;
+    },
+    regExp: /^(\s*)(?:-\s)?\s?(\[(\s|x)?\])\s/i,
+    replace: listReplace('check'),
+    type: 'element',
+};
+const MENTION_TRANSFORMER = {
+    type: 'text-match',
+    trigger: '<',
+    dependencies: [mention_node_1.MentionNode],
+    importRegExp: (0, peers_sdk_1.mentionRegex)(),
+    regExp: (0, peers_sdk_1.mentionRegex)(),
+    export: (node) => {
+        if ((0, mention_node_1.$isMentionNode)(node)) {
+            return (0, peers_sdk_1.formatMention)(node.data);
+        }
+        return null;
+    },
+    replace: (textNode, match) => {
+        const kind = match[2];
+        const name = match[3].replace(/_/g, ' ');
+        const id = match[4];
+        const data = {
+            kind: kind,
+            name,
+            id,
+            clickable: false,
+        };
+        const node = (0, mention_node_1.$createMentionNode)(data);
+        textNode.replace(node);
+    },
+};
+exports.PRESERVE_NEWLINES = {
+    type: 'element',
+    dependencies: [lexical_1.ParagraphNode],
+    export: (node) => {
+        if ((0, lexical_1.$isParagraphNode)(node)) {
+            const content = node.getTextContent();
+            if (!content.trim()) {
+                return '\n \n';
+            }
+        }
+        return null;
+    },
+    regExp: /^ $/, // a line with only a space
+    replace: (textNode, nodes, _, isImport) => {
+        if (isImport && nodes.length === 1) {
+            textNode.append((0, lexical_1.$createTextNode)(''));
+        }
+    },
+};
+exports.customMarkdownTransformers = [
+    exports.PRESERVE_NEWLINES,
+    MENTION_TRANSFORMER,
+    CHECK_LIST_TRANSFORMER, // This needs to be first or checklists will be treated as unordered lists
+    ...markdown_1.TRANSFORMERS.filter(transformer => {
+        const t = transformer;
+        // disable headings for this markdown since these are inline messages
+        if (t.dependencies?.[0]?.name === 'HeadingNode') {
+            return false;
+        }
+        return true;
+    }),
+];
+function MarkdownPlugin(props) {
+    const [editor] = (0, LexicalComposerContext_1.useLexicalComposerContext)();
+    const { markdownObs } = props;
+    (0, react_1.useEffect)(() => {
+        let markdown = '';
+        function setMarkdown() {
+            const newMarkdown = markdownObs() || '';
+            if (newMarkdown === markdown) {
+                return;
+            }
+            markdown = newMarkdown;
+            editor.update(() => {
+                const shouldPreserveNewLines = false;
+                const shouldMergeAdjacentLines = false;
+                (0, markdown_1.$convertFromMarkdownString)(markdown, exports.customMarkdownTransformers, undefined, shouldPreserveNewLines, shouldMergeAdjacentLines);
+            });
+        }
+        setMarkdown();
+        const sub = markdownObs.subscribe(() => {
+            setMarkdown();
+        });
+        const sub2Dispose = editor.registerUpdateListener(({ editorState }) => {
+            editor.update(() => {
+                const shouldPreserveNewLines = false;
+                let newMarkdown = (0, markdown_1.$convertToMarkdownString)(exports.customMarkdownTransformers, undefined, shouldPreserveNewLines);
+                newMarkdown = newMarkdown.replace(/\n\n\n \n\n\n/gm, '\n\n \n\n');
+                if (newMarkdown === "\n \n") {
+                    newMarkdown = '';
+                }
+                if (newMarkdown !== markdown) {
+                    markdown = newMarkdown;
+                    markdownObs(markdown);
+                }
+            });
+        });
+        return () => {
+            sub.dispose();
+            sub2Dispose();
+        };
+    }, [editor]);
+    return null;
+}

package/dist/components/markdown-editor/mention-node.d.ts

@@ -0,0 +1,21 @@
+import { type DOMConversionMap, type DOMExportOutput, type EditorConfig, type LexicalNode, type NodeKey, type SerializedTextNode, type Spread, TextNode } from 'lexical';
+import { IMentionData } from "@peers-app/peers-sdk";
+export type SerializedMentionNode = Spread<{
+    data: IMentionData;
+}, SerializedTextNode>;
+export declare class MentionNode extends TextNode {
+    readonly data: IMentionData;
+    static getType(): string;
+    static clone(node: MentionNode): MentionNode;
+    static importJSON(serializedNode: SerializedMentionNode): MentionNode;
+    constructor(data: IMentionData, key?: NodeKey);
+    exportJSON(): SerializedMentionNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    isTextEntity(): true;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+}
+export declare function $createMentionNode(data: IMentionData): MentionNode;
+export declare function $isMentionNode(node: LexicalNode | null | undefined): node is MentionNode;