@lobehub/editor 1.0.0

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

@@ -0,0 +1,26 @@
+import { DOMConversionMap, DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, SerializedLexicalNode, Spread } from 'lexical';
+export type SerializedMentionNode = Spread<{
+    extra?: Record<string, unknown>;
+    label?: string;
+}, 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;
+    __extra: Record<string, unknown>;
+    constructor(label?: string, extra?: Record<string, unknown>, key?: string);
+    get label(): string;
+    get extra(): 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, extra?: Record<string, unknown>): MentionNode;
+export declare function $isMentionNode(node: LexicalNode): node is MentionNode;

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

@@ -0,0 +1,143 @@
+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 extra = 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), "__extra", void 0);
+    _this.__label = label;
+    _this.__extra = extra;
+    return _this;
+  }
+  _createClass(MentionNode, [{
+    key: "label",
+    get: function get() {
+      return this.__label;
+    }
+  }, {
+    key: "extra",
+    get: function get() {
+      return this.__extra;
+    }
+  }, {
+    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)), {}, {
+        extra: this.extra,
+        label: this.label
+      });
+    }
+  }, {
+    key: "updateFromJSON",
+    value: function updateFromJSON(serializedNode) {
+      var node = _get(_getPrototypeOf(MentionNode.prototype), "updateFromJSON", this).call(this, serializedNode);
+      this.__label = serializedNode.label || '';
+      this.__extra = serializedNode.extra || {};
+      return node;
+    }
+  }, {
+    key: "decorate",
+    value: function decorate(editor) {
+      var _getKernelFromEditor, _getKernelFromEditor$;
+      return ((_getKernelFromEditor = getKernelFromEditor(editor)) === null || _getKernelFromEditor === void 0 || (_getKernelFromEditor$ = _getKernelFromEditor.getDecorator('mention')) === null || _getKernelFromEditor$ === void 0 ? void 0 : _getKernelFromEditor$(this, editor)) || null;
+    }
+  }], [{
+    key: "getType",
+    value: function getType() {
+      return 'mention';
+    }
+  }, {
+    key: "clone",
+    value: function clone(node) {
+      return new MentionNode(node.__label, node.__extra, 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, extra) {
+  return $applyNodeReplacement(new MentionNode(label, extra));
+}
+function $convertMentionElement() {
+  return {
+    node: $createMentionNode()
+  };
+}
+export function $isMentionNode(node) {
+  return node.getType() === MentionNode.getType();
+}

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

@@ -0,0 +1,11 @@
+import { LexicalEditor } from 'lexical';
+import type { IEditorPluginConstructor } from "../../../types";
+import { MentionNode } from '../node/MentionNode';
+export interface MentionPluginOptions {
+    decorator: (node: MentionNode, editor: LexicalEditor) => any;
+    markdownWriter?: (file: MentionNode) => string;
+    theme?: {
+        mention?: string;
+    };
+}
+export declare const MentionPlugin: IEditorPluginConstructor<MentionPluginOptions>;

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

@@ -0,0 +1,61 @@
+var _class;
+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 _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 _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); }
+import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { IMarkdownShortCutService } from "../../markdown";
+import { registerMentionCommand } from "../command";
+import { $isMentionNode, MentionNode } from "../node/MentionNode";
+import { registerMentionNodeSelectionObserver } from "./register";
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+export var MentionPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(MentionPlugin, _KernelPlugin);
+  var _super = _createSuper(MentionPlugin);
+  function MentionPlugin(kernel, config) {
+    var _kernel$requireServic;
+    var _this;
+    _classCallCheck(this, MentionPlugin);
+    _this = _super.call(this);
+    // Register the file node
+    _this.kernel = kernel;
+    _this.config = config;
+    kernel.registerNodes([MentionNode]);
+    if (config !== null && config !== void 0 && config.theme) {
+      kernel.registerThemes(config === null || config === void 0 ? void 0 : config.theme);
+    }
+    kernel.registerDecorator(MentionNode.getType(), function (node, editor) {
+      return config !== null && config !== void 0 && config.decorator ? config.decorator(node, editor) : null;
+    });
+    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownWriter(MentionNode.getType(), function (ctx, node) {
+      if ($isMentionNode(node)) {
+        if (config !== null && config !== void 0 && config.markdownWriter) {
+          ctx.appendLine(config.markdownWriter(node));
+          return;
+        }
+        ctx.appendLine("".concat(node.label));
+      }
+    });
+    return _this;
+  }
+  _createClass(MentionPlugin, [{
+    key: "onInit",
+    value: function onInit(editor) {
+      this.register(registerMentionCommand(editor));
+      this.register(registerMentionNodeSelectionObserver(editor));
+    }
+  }]);
+  return MentionPlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'MentionPlugin'), _class);

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

@@ -0,0 +1,2 @@
+import { LexicalEditor } from 'lexical';
+export declare function registerMentionNodeSelectionObserver(editor: LexicalEditor): () => void;

package/es/plugins/mention/plugin/register.js

@@ -0,0 +1,46 @@
+import { $getSelection, $isNodeSelection, $isRangeSelection } from 'lexical';
+import { $isMentionNode } from "../node/MentionNode";
+export function registerMentionNodeSelectionObserver(editor) {
+  var selectMentionKeys = [];
+  return editor.registerUpdateListener(function (_ref) {
+    var editorState = _ref.editorState;
+    var selection = editorState.read(function () {
+      return $getSelection();
+    });
+    var newSelectMentionKeys = [];
+    if ($isNodeSelection(selection)) {
+      var nodes = editorState.read(function () {
+        return selection.getNodes();
+      });
+      nodes.forEach(function (node) {
+        if (node.getType() === 'mention') {
+          newSelectMentionKeys.push(node.getKey());
+        }
+      });
+    } else if ($isRangeSelection(selection) && !selection.isCollapsed()) {
+      editorState.read(function () {
+        selection.getNodes().forEach(function (node) {
+          if ($isMentionNode(node)) {
+            newSelectMentionKeys.push(node.getKey());
+          }
+        });
+      });
+    }
+    var removeKeys = selectMentionKeys.filter(function (key) {
+      return !newSelectMentionKeys.includes(key);
+    });
+    var addKeys = newSelectMentionKeys.filter(function (key) {
+      return !selectMentionKeys.includes(key);
+    });
+    selectMentionKeys.length = 0;
+    selectMentionKeys.push.apply(selectMentionKeys, newSelectMentionKeys);
+    removeKeys.forEach(function (key) {
+      var _editor$getElementByK;
+      (_editor$getElementByK = editor.getElementByKey(key)) === null || _editor$getElementByK === void 0 || _editor$getElementByK.classList.remove('selected');
+    });
+    addKeys.forEach(function (key) {
+      var _editor$getElementByK2;
+      (_editor$getElementByK2 = editor.getElementByKey(key)) === null || _editor$getElementByK2 === void 0 || _editor$getElementByK2.classList.add('selected');
+    });
+  });
+}

package/es/plugins/mention/react/ReactMentionPlugin.d.ts

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+import type { ReactMentionPluginProps } from './type';
+declare const ReactMentionPlugin: FC<ReactMentionPluginProps>;
+export default ReactMentionPlugin;

package/es/plugins/mention/react/ReactMentionPlugin.js

@@ -0,0 +1,42 @@
+'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";
+import { MentionPlugin } from "../plugin";
+import Mention from "./components/Mention";
+import { useStyles } from "./style";
+import { jsx as _jsx } from "react/jsx-runtime";
+var ReactMentionPlugin = function ReactMentionPlugin(_ref) {
+  var className = _ref.className,
+    theme = _ref.theme,
+    markdownWriter = _ref.markdownWriter;
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  var _useStyles = useStyles(),
+    styles = _useStyles.styles;
+  useLayoutEffect(function () {
+    editor.registerPlugin(MarkdownPlugin);
+    editor.registerPlugin(MentionPlugin, {
+      decorator: function decorator(node, editor) {
+        return /*#__PURE__*/_jsx(Mention, {
+          className: className,
+          editor: editor,
+          node: node
+        });
+      },
+      markdownWriter: markdownWriter,
+      theme: theme || styles
+    });
+  }, [editor]);
+  return null;
+};
+ReactMentionPlugin.displayName = 'ReactMentionPlugin';
+export default ReactMentionPlugin;

package/es/plugins/mention/react/components/Mention.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { LexicalEditor } from 'lexical';
+import { MentionNode } from '../../node/MentionNode';
+declare const Mention: import("react").NamedExoticComponent<{
+    className?: string | undefined;
+    editor: LexicalEditor;
+    node: MentionNode;
+}>;
+export default Mention;

package/es/plugins/mention/react/components/Mention.js

@@ -0,0 +1,39 @@
+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 { CLICK_COMMAND, COMMAND_PRIORITY_LOW } from 'lexical';
+import { memo, useCallback, useEffect, useRef } from 'react';
+import { useLexicalNodeSelection } from "../../../../editor-kernel/react/useLexicalNodeSelection";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var Mention = /*#__PURE__*/memo(function (_ref) {
+  var node = _ref.node,
+    editor = _ref.editor,
+    className = _ref.className;
+  var spanRef = useRef(null);
+  var _useLexicalNodeSelect = useLexicalNodeSelection(node.getKey()),
+    _useLexicalNodeSelect2 = _slicedToArray(_useLexicalNodeSelect, 3),
+    setSelected = _useLexicalNodeSelect2[1],
+    clearSelection = _useLexicalNodeSelect2[2];
+  var onClick = useCallback(function (payload) {
+    if (payload.target === spanRef.current) {
+      clearSelection();
+      setSelected(true);
+      return true; // Indicate that the click was handled
+    }
+    return false;
+  }, [clearSelection, setSelected]);
+  useEffect(function () {
+    // Perform any necessary side effects here
+    return editor.registerCommand(CLICK_COMMAND, onClick, COMMAND_PRIORITY_LOW);
+  }, [editor, node, onClick]);
+  return /*#__PURE__*/_jsxs("span", {
+    className: className,
+    ref: spanRef,
+    children: ["@", node.label]
+  });
+});
+Mention.displayName = 'Mention';
+export default Mention;

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

@@ -0,0 +1,2 @@
+export { default as ReactMentionPlugin } from './ReactMentionPlugin';
+export type * from './type';

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

@@ -0,0 +1 @@
+export { default as ReactMentionPlugin } from "./ReactMentionPlugin";

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

@@ -0,0 +1,3 @@
+export declare const useStyles: (props?: unknown) => import("antd-style").ReturnStyles<{
+    mention: import("antd-style").SerializedStyles;
+}>;

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

@@ -0,0 +1,11 @@
+var _templateObject;
+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 { createStyles } from 'antd-style';
+export var useStyles = createStyles(function (_ref) {
+  var css = _ref.css,
+    token = _ref.token;
+  return {
+    mention: css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    user-select: none;\n\n    position: relative;\n\n    display: inline;\n\n    margin-inline: 0.25em;\n    padding-block: 0.2em;\n    padding-inline: 0.4em;\n    border: 1px solid ", ";\n    border-radius: 0.25em;\n\n    font-size: 0.875em;\n    line-height: 1;\n    color: ", ";\n    word-break: break-word;\n    white-space: break-spaces;\n\n    background: ", ";\n\n    &.selected {\n      color: #000;\n      background: ", ";\n    }\n  "])), token.colorInfoFillTertiary, token.colorInfo, token.colorInfoFillTertiary, token.yellow)
+  };
+});

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

@@ -0,0 +1,8 @@
+import type { MentionNode } from "../node/MentionNode";
+export interface ReactMentionPluginProps {
+    className?: string;
+    markdownWriter?: (file: MentionNode) => string;
+    theme?: {
+        mention?: string;
+    };
+}

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

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

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

@@ -0,0 +1,3 @@
+export * from './plugin';
+export * from './react';
+export type { ISlashService, SlashOptions } from './service/i-slash-service';

package/es/plugins/slash/index.js

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

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

@@ -0,0 +1,23 @@
+import type { IEditorPluginConstructor } from "../../../types";
+import { ISlashOption, SlashOptions } from '../service/i-slash-service';
+export interface ITriggerContext {
+    getRect: () => DOMRect;
+    items: Array<ISlashOption> | ((search: {
+        leadOffset: number;
+        matchingString: string;
+        replaceableString: string;
+    } | null) => Promise<Array<ISlashOption>>);
+    lastIndex: number;
+    match?: {
+        leadOffset: number;
+        matchingString: string;
+        replaceableString: string;
+    } | null;
+    trigger: SlashOptions['trigger'];
+}
+export interface SlashPluginOptions {
+    slashOptions?: SlashOptions[];
+    triggerClose: () => void;
+    triggerOpen: (ctx: ITriggerContext) => void;
+}
+export declare const SlashPlugin: IEditorPluginConstructor<SlashPluginOptions>;

package/es/plugins/slash/plugin/index.js

@@ -0,0 +1,132 @@
+var _class;
+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 _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); }
+import { $getSelection, $isRangeSelection } from 'lexical';
+import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ISlashService, SlashService } from "../service/i-slash-service";
+import { getQueryTextForSearch, tryToPositionRange } from "../utils/utils";
+export var SlashPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(SlashPlugin, _KernelPlugin);
+  var _super = _createSuper(SlashPlugin);
+  function SlashPlugin(kernel, config) {
+    var _this;
+    _classCallCheck(this, SlashPlugin);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "service", null);
+    _defineProperty(_assertThisInitialized(_this), "currentSlashTrigger", null);
+    _defineProperty(_assertThisInitialized(_this), "currentSlashTriggerIndex", -1);
+    _this.config = config;
+    _this.service = new SlashService(kernel);
+    kernel.registerService(ISlashService, _this.service);
+    if (config !== null && config !== void 0 && config.slashOptions) {
+      config.slashOptions.forEach(function (option) {
+        var _this$service;
+        (_this$service = _this.service) === null || _this$service === void 0 || _this$service.registerSlash(option);
+      });
+    }
+    return _this;
+  }
+  _createClass(SlashPlugin, [{
+    key: "triggerClose",
+    value: function triggerClose() {
+      var _this$config;
+      (_this$config = this.config) === null || _this$config === void 0 || _this$config.triggerClose();
+      this.currentSlashTrigger = null;
+      this.currentSlashTriggerIndex = -1;
+    }
+  }, {
+    key: "onInit",
+    value: function onInit(editor) {
+      var _this2 = this;
+      this.register(editor.registerUpdateListener(function () {
+        editor.getEditorState().read(function () {
+          var _this2$service, _this2$service2, _this2$service3;
+          if (!editor.isEditable()) {
+            // Trigger close
+            _this2.triggerClose();
+            return;
+          }
+          var isComposing = editor.isComposing();
+          if (isComposing) {
+            // Currently typing, do not handle
+            return;
+          }
+          var editorWindow = editor._window || window;
+          // Skip on server side
+          if (editorWindow === undefined || !editorWindow.document) {
+            return;
+          }
+          var range = editorWindow.document.createRange();
+          var selection = $getSelection();
+          var text = getQueryTextForSearch(editor);
+          if (!$isRangeSelection(selection) || !selection.isCollapsed() ||
+          // Do not trigger inside code
+          selection.hasFormat('code') || text === null || range === null || _this2.currentSlashTrigger === null && text.length > 1 && text.at(-2) !== ' ') {
+            _this2.triggerClose();
+            return;
+          }
+          var triggerText = _this2.currentSlashTrigger;
+          if (triggerText === null) {
+            triggerText = text.slice(-1);
+            _this2.currentSlashTriggerIndex = text.length - 1;
+          }
+          var lastIndex = text.lastIndexOf(triggerText);
+          if (lastIndex < _this2.currentSlashTriggerIndex) {
+            _this2.triggerClose();
+            return;
+          }
+          var slashOptions = (_this2$service = _this2.service) === null || _this2$service === void 0 ? void 0 : _this2$service.getSlashOptions(triggerText);
+          var maxLength = (slashOptions === null || slashOptions === void 0 ? void 0 : slashOptions.maxLength) || 75;
+
+          // Exceeds maximum length
+          if (text.length - lastIndex > maxLength || !slashOptions) {
+            _this2.triggerClose();
+            return;
+          }
+          var triggerFn = (_this2$service2 = _this2.service) === null || _this2$service2 === void 0 ? void 0 : _this2$service2.getSlashTriggerFn(triggerText);
+          var fuse = (_this2$service3 = _this2.service) === null || _this2$service3 === void 0 ? void 0 : _this2$service3.getSlashFuse(triggerText);
+          var isRangePositioned = tryToPositionRange(_this2.currentSlashTriggerIndex, range, editorWindow);
+          var match = triggerFn === null || triggerFn === void 0 ? void 0 : triggerFn(text.slice(_this2.currentSlashTriggerIndex));
+          var finalItems = fuse && match && match.matchingString.length > 0 ? fuse.search(match.matchingString).map(function (result) {
+            return result.item;
+          }) : slashOptions.items;
+          if (isRangePositioned !== null && finalItems.length > 0) {
+            var _this2$config;
+            _this2.currentSlashTrigger = triggerText;
+            (_this2$config = _this2.config) === null || _this2$config === void 0 || _this2$config.triggerOpen({
+              getRect: function getRect() {
+                return range.getBoundingClientRect();
+              },
+              items: finalItems,
+              lastIndex: lastIndex,
+              match: match,
+              trigger: slashOptions.trigger
+            });
+            return;
+          }
+          _this2.triggerClose();
+        });
+      }));
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      _get(_getPrototypeOf(SlashPlugin.prototype), "destroy", this).call(this);
+    }
+  }]);
+  return SlashPlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'slash'), _class);

package/es/plugins/slash/react/ReactSlashOption.d.ts

@@ -0,0 +1,4 @@
+import type { FC } from 'react';
+import type { ReactSlashOptionProps } from './type';
+declare const ReactSlashOption: FC<ReactSlashOptionProps>;
+export default ReactSlashOption;

package/es/plugins/slash/react/ReactSlashOption.js

@@ -0,0 +1,7 @@
+'use client';
+
+var ReactSlashOption = function ReactSlashOption() {
+  return null;
+};
+ReactSlashOption.displayName = 'ReactSlashOption';
+export default ReactSlashOption;

package/es/plugins/slash/react/ReactSlashPlugin.d.ts

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+import type { ReactSlashPluginProps } from './type';
+declare const ReactSlashPlugin: FC<ReactSlashPluginProps>;
+export default ReactSlashPlugin;