@lobehub/editor 4.5.0 → 4.6.0

package/es/plugins/math/react/components/MathInline.js

@@ -1,136 +0,0 @@
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-import { addClassNamesToElement, removeClassNamesFromElement } from '@lexical/utils';
-import Katex from 'katex';
-import { $getSelection, $isNodeSelection } from 'lexical';
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { useLexicalEditor } from "../../../../editor-kernel/react";
-import { useLexicalNodeSelection } from "../../../../editor-kernel/react/useLexicalNodeSelection";
-import { createDebugLogger } from "../../../../utils/debug";
-import { $isMathNode, MathBlockNode } from "../../node";
-import Placeholder from "./Placeholder";
-import { jsx as _jsx } from "react/jsx-runtime";
-var logger = createDebugLogger('plugin', 'math');
-var MathInline = function MathInline(_ref) {
-  var editor = _ref.editor,
-    node = _ref.node,
-    className = _ref.className;
-  var ref = useRef(null);
-  var _useLexicalNodeSelect = useLexicalNodeSelection(node.getKey()),
-    _useLexicalNodeSelect2 = _slicedToArray(_useLexicalNodeSelect, 3),
-    isSelected = _useLexicalNodeSelect2[0],
-    setIsSelected = _useLexicalNodeSelect2[1],
-    clearSelected = _useLexicalNodeSelect2[2];
-  var _useState = useState(false),
-    _useState2 = _slicedToArray(_useState, 2),
-    isEditing = _useState2[0],
-    setIsEditing = _useState2[1];
-  var isMathBlock = node instanceof MathBlockNode;
-  useEffect(function () {
-    if (ref.current && node.code) {
-      Katex.render(node.code, ref.current, {
-        // 使用 displayMode 渲染块级公式
-        displayMode: node instanceof MathBlockNode,
-        throwOnError: false
-      });
-    }
-  }, [node.code]);
-  useEffect(function () {
-    var parent = editor.getElementByKey(node.getKey());
-    if (parent) {
-      // 防抖处理，避免过于频繁的 DOM 操作
-      var timeoutId = setTimeout(function () {
-        if (isEditing) {
-          addClassNamesToElement(parent, 'editing');
-          removeClassNamesFromElement(parent, 'selected');
-        } else if (isSelected) {
-          addClassNamesToElement(parent, 'selected');
-          removeClassNamesFromElement(parent, 'editing');
-        } else {
-          removeClassNamesFromElement(parent, 'selected');
-          removeClassNamesFromElement(parent, 'editing');
-        }
-      }, 10);
-      return function () {
-        return clearTimeout(timeoutId);
-      };
-    }
-  }, [isSelected, isEditing, editor, node]);
-
-  // useLexicalEditor(
-  //   (editor) => {
-  //     return editor.registerCommand(
-  //       CLICK_COMMAND,
-  //       (payload) => {
-  //         logger.debug('📊 Math click event:', payload.target === ref.current);
-  //         if (payload.target && payload.target instanceof Node) {
-  //           // 获取节点对应的 DOM 元素
-  //           const nodeElement = editor.getElementByKey(node.getKey());
-
-  //           // 对于 block 模式，检查是否点击在整个节点容器内
-  //           // 对于 inline 模式，仍然检查是否点击在渲染内容内
-  //           const isClickInNode =
-  //             node instanceof MathBlockNode
-  //               ? nodeElement?.contains(payload.target)
-  //               : ref.current?.contains(payload.target);
-
-  //           if (isClickInNode) {
-  //             setSelected(true);
-  //           }
-  //         }
-  //         return false;
-  //       },
-  //       COMMAND_PRIORITY_NORMAL,
-  //     );
-  //   },
-  //   [node],
-  // );
-
-  // 监听编辑器状态变化来检测编辑状态
-  useLexicalEditor(function (editor) {
-    return editor.registerUpdateListener(function () {
-      editor.getEditorState().read(function () {
-        var selection = $getSelection();
-        if (!$isNodeSelection(selection)) {
-          setIsEditing(false);
-          return;
-        }
-        var selectedNode = selection.getNodes()[0];
-        if (!$isMathNode(selectedNode)) {
-          setIsEditing(false);
-          return;
-        }
-        // 检查是否选中的是当前节点，且有数学编辑器显示
-        if (selectedNode.getKey() === node.getKey()) {
-          setIsEditing(true);
-        } else {
-          setIsEditing(false);
-        }
-      });
-    });
-  }, [node]);
-  var handleClick = useCallback(function (e) {
-    logger.debug('📊 Math click event:', e.target === ref.current);
-    e.preventDefault();
-    e.stopPropagation();
-    if (isSelected) {
-      // 强制触发一次 selection 更新，确保打开编辑器面板
-      clearSelected();
-    }
-    setIsSelected(true);
-    editor.focus();
-  }, [clearSelected, editor, isSelected, setIsSelected]);
-  return /*#__PURE__*/_jsx("span", {
-    className: className,
-    onClick: handleClick,
-    ref: ref,
-    children: node.code ? node.code : /*#__PURE__*/_jsx(Placeholder, {
-      mathBlock: isMathBlock
-    })
-  });
-};
-export default MathInline;

package/es/plugins/math/react/components/Placeholder.d.ts

@@ -1,6 +0,0 @@
-import { type FC } from 'react';
-interface PlaceholderProps {
-    mathBlock?: boolean;
-}
-declare const Placeholder: FC<PlaceholderProps>;
-export default Placeholder;

package/es/plugins/math/react/components/Placeholder.js

@@ -1,23 +0,0 @@
-import { Center, Text } from '@lobehub/ui';
-import { cx } from 'antd-style';
-import { useTranslation } from "../../../../editor-kernel/react/useTranslation";
-import { styles } from "../style";
-import { jsx as _jsx } from "react/jsx-runtime";
-var Placeholder = function Placeholder(_ref) {
-  var mathBlock = _ref.mathBlock;
-  var t = useTranslation();
-  var node = /*#__PURE__*/_jsx(Text, {
-    as: 'span',
-    className: cx('katex', styles.mathPlaceholder),
-    fontSize: mathBlock ? '1.2em' : '1em',
-    type: 'secondary',
-    children: t('math.placeholder')
-  });
-  if (!mathBlock) return node;
-  return /*#__PURE__*/_jsx(Center, {
-    padding: 18,
-    width: '100%',
-    children: node
-  });
-};
-export default Placeholder;

package/es/plugins/math/react/index.d.ts

@@ -1,3 +0,0 @@
-import { type FC } from 'react';
-import { ReactMathPluginProps } from './type';
-export declare const ReactMathPlugin: FC<ReactMathPluginProps>;

package/es/plugins/math/react/index.js

@@ -1,41 +0,0 @@
-'use client';
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-import { useLayoutEffect } from 'react';
-import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
-import { MarkdownPlugin } from "../../markdown/plugin";
-import { MathPlugin } from "../plugin";
-import MathEdit from "./components/MathEditor";
-import MathInline from "./components/MathInline";
-import { styles } from "./style";
-import { jsx as _jsx } from "react/jsx-runtime";
-export var ReactMathPlugin = function ReactMathPlugin(_ref) {
-  var className = _ref.className,
-    renderComp = _ref.renderComp,
-    theme = _ref.theme;
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  useLayoutEffect(function () {
-    editor.registerPlugin(MarkdownPlugin);
-    editor.registerPlugin(MathPlugin, {
-      decorator: function decorator(node, editor) {
-        return /*#__PURE__*/_jsx(MathInline, {
-          className: className,
-          editor: editor,
-          node: node
-        });
-      },
-      theme: theme || styles
-    });
-  }, [editor, className, theme, styles]);
-  return /*#__PURE__*/_jsx(MathEdit, {
-    renderComp: renderComp
-  });
-};
-ReactMathPlugin.displayName = 'ReactMathPlugin';

package/es/plugins/math/react/style.d.ts

@@ -1,9 +0,0 @@
-export declare const styles: {
-    mathInline: string;
-    mathBlock: string;
-    mathEditor: string;
-    mathEditorFooter: string;
-    mathEditorAnchor: string;
-    mathEditorTextArea: string;
-    mathPlaceholder: string;
-};

package/es/plugins/math/react/style.js

@@ -1,18 +0,0 @@
-var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8;
-function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-/* eslint-disable sort-keys-fix/sort-keys-fix */
-import { createStaticStyles, cx } from 'antd-style';
-export var styles = createStaticStyles(function (_ref) {
-  var css = _ref.css,
-    cssVar = _ref.cssVar;
-  var latex = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    cursor: pointer;\n    user-select: none;\n    font-size: 1em;\n\n    .katex-error {\n      color: ", " !important;\n    }\n\n    .katex-html {\n      overflow: auto hidden;\n      padding: 3px;\n\n      .base {\n        margin-block: 0;\n        margin-inline: auto;\n      }\n\n      .tag {\n        position: relative !important;\n        display: inline-block;\n        padding-inline-start: 0.5rem;\n      }\n    }\n\n    &.selected {\n      color: #000;\n      background: ", ";\n    }\n\n    &:hover {\n      background: ", ";\n    }\n\n    &.editing {\n      background: ", ";\n    }\n\n    &:has(.katex-error) {\n      background: ", ";\n    }\n  "])), cssVar.colorError, cssVar.yellow, cssVar.colorFillTertiary, cssVar.colorFillTertiary, cssVar.colorErrorBg);
-  return {
-    mathInline: cx(latex, css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n        display: inline-block;\n        border-radius: calc(var(--lobe-markdown-border-radius) * 0.5px);\n      "])))),
-    mathBlock: cx(latex, css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n        overflow: auto hidden;\n        display: block;\n        border-radius: calc(var(--lobe-markdown-border-radius) * 1px);\n        white-space: nowrap;\n      "])))),
-    mathEditor: css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n      width: 320px;\n      background: ", ";\n\n      textarea {\n        width: 100%;\n\n        font-family: ", ";\n        font-size: 13px;\n\n        background: transparent !important;\n\n        transition: none !important;\n      }\n    "])), cssVar.colorBgElevated, cssVar.fontFamilyCode),
-    mathEditorFooter: css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n      border-block-start: 1px solid ", ";\n      background: ", ";\n    "])), cssVar.colorBorderSecondary, cssVar.colorFillQuaternary),
-    mathEditorAnchor: css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n      pointer-events: none;\n\n      position: absolute;\n      inset-block-start: -9999px;\n      inset-inline-start: -9999px;\n\n      width: 0;\n      height: 0;\n    "]))),
-    mathEditorTextArea: css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n      margin-block: 4px;\n    "]))),
-    mathPlaceholder: css(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n      padding-inline: 0.2em;\n      font-style: italic;\n    "])))
-  };
-});

package/es/plugins/math/react/type.d.ts

@@ -1,13 +0,0 @@
-import type { FC, ReactNode } from 'react';
-export interface ReactMathPluginProps {
-    className?: string;
-    /** 自定义渲染组件，接收 MathEditorContent 作为子节点 */
-    renderComp?: FC<{
-        children: ReactNode;
-        open?: boolean;
-    }>;
-    theme?: {
-        mathBlock?: string;
-        mathInline?: string;
-    };
-}

package/es/plugins/math/react/type.js

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

package/es/plugins/math/utils/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Heuristic: does the content between `$...$` look like a math formula?
- *
- * Positive signals (any one → math):
- *  - LaTeX commands        \alpha  \frac  …
- *  - Structural chars      ^ _ { } ( )
- *  - Operators / relations  + - * / = < > | ! ,
- *  - Digits                0-9
- *  - Single ASCII letter   x  y  n  (common math variable)
- *
- * Everything else (multi-char words, CJK, spaced plain text) → not math.
- */
-export declare function isLikelyMathContent(content: string): boolean;

package/es/plugins/math/utils/index.js

@@ -1,26 +0,0 @@
-/**
- * Heuristic: does the content between `$...$` look like a math formula?
- *
- * Positive signals (any one → math):
- *  - LaTeX commands        \alpha  \frac  …
- *  - Structural chars      ^ _ { } ( )
- *  - Operators / relations  + - * / = < > | ! ,
- *  - Digits                0-9
- *  - Single ASCII letter   x  y  n  (common math variable)
- *
- * Everything else (multi-char words, CJK, spaced plain text) → not math.
- */
-export function isLikelyMathContent(content) {
-  var trimmed = content.trim();
-  if (!trimmed) return false;
-
-  // LaTeX commands
-  if (/\\[A-Za-z]/.test(trimmed)) return true;
-
-  // Math structural chars, operators, or digits
-  if (/[\d!()*+,/<=>^_{|}-]/.test(trimmed)) return true;
-
-  // Single ASCII letter → likely a variable (x, y, n, …)
-  if (/^[A-Za-z]$/.test(trimmed)) return true;
-  return false;
-}

package/es/plugins/mention/command/index.d.ts

@@ -1,6 +0,0 @@
-import { LexicalEditor } from 'lexical';
-export declare const INSERT_MENTION_COMMAND: import("lexical").LexicalCommand<{
-    label: string;
-    metadata?: Record<string, unknown> | undefined;
-}>;
-export declare function registerMentionCommand(editor: LexicalEditor): () => void;

package/es/plugins/mention/command/index.js

@@ -1,20 +0,0 @@
-import { $wrapNodeInElement } from '@lexical/utils';
-import { $createParagraphNode, $insertNodes, $isRootOrShadowRoot, COMMAND_PRIORITY_HIGH, createCommand } from 'lexical';
-import { $createMentionNode } from "../node/MentionNode";
-export var INSERT_MENTION_COMMAND = createCommand('INSERT_MENTION_COMMAND');
-export function registerMentionCommand(editor) {
-  return editor.registerCommand(INSERT_MENTION_COMMAND, function (payload) {
-    var metadata = payload.metadata,
-      label = payload.label;
-    editor.update(function () {
-      var mentionNode = $createMentionNode(label, metadata);
-      $insertNodes([mentionNode]);
-      // Ensure mention is inside a paragraph when inserted at root
-      if ($isRootOrShadowRoot(mentionNode.getParentOrThrow())) {
-        $wrapNodeInElement(mentionNode, $createParagraphNode).selectEnd();
-      }
-    });
-    return true;
-  }, COMMAND_PRIORITY_HIGH // Priority
-  );
-}

package/es/plugins/mention/index.d.ts

@@ -1,4 +0,0 @@
-export { INSERT_MENTION_COMMAND } from './command';
-export type { SerializedMentionNode } from './node/MentionNode';
-export * from './plugin';
-export * from './react';

package/es/plugins/mention/index.js

@@ -1,3 +0,0 @@
-export { INSERT_MENTION_COMMAND } from "./command";
-export * from "./plugin";
-export * from "./react";

package/es/plugins/mention/node/MentionNode.d.ts

@@ -1,26 +0,0 @@
-import { DOMConversionMap, DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, SerializedLexicalNode, Spread } from 'lexical';
-export type SerializedMentionNode = Spread<{
-    label?: string;
-    metadata?: Record<string, unknown>;
-}, SerializedLexicalNode>;
-export declare class MentionNode extends DecoratorNode<any> {
-    static getType(): string;
-    static clone(node: MentionNode): MentionNode;
-    static importJSON(serializedNode: SerializedMentionNode): MentionNode;
-    static importDOM(): DOMConversionMap | null;
-    __label: string;
-    __metadata: Record<string, unknown>;
-    constructor(label?: string, metadata?: Record<string, unknown>, key?: string);
-    get label(): string;
-    get metadata(): Record<string, unknown>;
-    exportDOM(): DOMExportOutput;
-    createDOM(config: EditorConfig): HTMLElement;
-    getTextContent(): string;
-    isInline(): true;
-    updateDOM(): boolean;
-    exportJSON(): SerializedMentionNode;
-    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedMentionNode>): this;
-    decorate(editor: LexicalEditor): any;
-}
-export declare function $createMentionNode(label?: string, metadata?: Record<string, unknown>): MentionNode;
-export declare function $isMentionNode(node: LexicalNode): node is MentionNode;

package/es/plugins/mention/node/MentionNode.js

@@ -1,153 +0,0 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/* eslint-disable @typescript-eslint/no-use-before-define */
-import { addClassNamesToElement } from '@lexical/utils';
-import { $applyNodeReplacement, DecoratorNode } from 'lexical';
-import { getKernelFromEditor } from "../../../editor-kernel/utils";
-export var MentionNode = /*#__PURE__*/function (_DecoratorNode) {
-  _inherits(MentionNode, _DecoratorNode);
-  var _super = _createSuper(MentionNode);
-  function MentionNode() {
-    var _this;
-    var label = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    var metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var key = arguments.length > 2 ? arguments[2] : undefined;
-    _classCallCheck(this, MentionNode);
-    _this = _super.call(this, key);
-    _defineProperty(_assertThisInitialized(_this), "__label", void 0);
-    _defineProperty(_assertThisInitialized(_this), "__metadata", void 0);
-    _this.__label = label;
-    _this.__metadata = metadata;
-    return _this;
-  }
-  _createClass(MentionNode, [{
-    key: "label",
-    get: function get() {
-      return this.__label;
-    }
-  }, {
-    key: "metadata",
-    get: function get() {
-      return this.__metadata;
-    }
-  }, {
-    key: "exportDOM",
-    value: function exportDOM() {
-      return {
-        element: document.createElement('span')
-      };
-    }
-  }, {
-    key: "createDOM",
-    value: function createDOM(config) {
-      var element = document.createElement('span');
-      addClassNamesToElement(element, config.theme.mention);
-      return element;
-    }
-  }, {
-    key: "getTextContent",
-    value: function getTextContent() {
-      return this.label;
-    }
-  }, {
-    key: "isInline",
-    value: function isInline() {
-      return true;
-    }
-  }, {
-    key: "updateDOM",
-    value: function updateDOM() {
-      return false;
-    }
-  }, {
-    key: "exportJSON",
-    value: function exportJSON() {
-      return _objectSpread(_objectSpread({}, _get(_getPrototypeOf(MentionNode.prototype), "exportJSON", this).call(this)), {}, {
-        label: this.label,
-        metadata: this.metadata
-      });
-    }
-  }, {
-    key: "updateFromJSON",
-    value: function updateFromJSON(serializedNode) {
-      var node = _get(_getPrototypeOf(MentionNode.prototype), "updateFromJSON", this).call(this, serializedNode);
-      this.__label = serializedNode.label || '';
-      this.__metadata = serializedNode.metadata || {};
-      return node;
-    }
-  }, {
-    key: "decorate",
-    value: function decorate(editor) {
-      var _getKernelFromEditor;
-      var decorator = (_getKernelFromEditor = getKernelFromEditor(editor)) === null || _getKernelFromEditor === void 0 ? void 0 : _getKernelFromEditor.getDecorator(MentionNode.getType());
-      if (!decorator) {
-        return null;
-      }
-      if (typeof decorator === 'function') {
-        return decorator(this, editor);
-      }
-      return {
-        queryDOM: decorator.queryDOM,
-        render: decorator.render(this, editor)
-      };
-    }
-  }], [{
-    key: "getType",
-    value: function getType() {
-      return 'mention';
-    }
-  }, {
-    key: "clone",
-    value: function clone(node) {
-      return new MentionNode(node.__label, node.__metadata, node.__key);
-    }
-  }, {
-    key: "importJSON",
-    value: function importJSON(serializedNode) {
-      return $createMentionNode().updateFromJSON(serializedNode);
-    }
-  }, {
-    key: "importDOM",
-    value: function importDOM() {
-      return {
-        span: function span(node) {
-          if (node.classList.contains('mention')) {
-            return {
-              conversion: $convertMentionElement,
-              priority: 0
-            };
-          }
-          return null;
-        }
-      };
-    }
-  }]);
-  return MentionNode;
-}(DecoratorNode);
-export function $createMentionNode(label, metadata) {
-  return $applyNodeReplacement(new MentionNode(label, metadata));
-}
-function $convertMentionElement() {
-  return {
-    node: $createMentionNode()
-  };
-}
-export function $isMentionNode(node) {
-  return node.getType() === MentionNode.getType();
-}

package/es/plugins/mention/plugin/index.d.ts

@@ -1,14 +0,0 @@
-import { LexicalEditor } from 'lexical';
-import { Html } from 'mdast';
-import { INode } from "../../../editor-kernel/inode";
-import type { IEditorPluginConstructor } from "../../../types";
-import { MentionNode, SerializedMentionNode } from '../node/MentionNode';
-export interface MentionPluginOptions {
-    decorator: (node: MentionNode, editor: LexicalEditor) => any;
-    markdownReader?: (node: Html, children: INode[]) => SerializedMentionNode | null | false;
-    markdownWriter?: (mention: MentionNode) => string;
-    theme?: {
-        mention?: string;
-    };
-}
-export declare const MentionPlugin: IEditorPluginConstructor<MentionPluginOptions>;