@lobehub/editor 1.0.0

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

@@ -0,0 +1,228 @@
+'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 { mergeRegister } from '@lexical/utils';
+import { COMMAND_PRIORITY_NORMAL, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND } from 'lexical';
+import { Children, useCallback, useLayoutEffect, useRef, useState } from 'react';
+import { useLexicalEditor } from "../../../editor-kernel/react";
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
+import { SlashPlugin } from "../plugin/index";
+import { $splitNodeContainingQuery } from "../utils/utils";
+import SlashMenu from "./components/SlashMenu";
+import { setCancelablePromise } from "./utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+var ReactSlashPlugin = function ReactSlashPlugin(_ref) {
+  var children = _ref.children,
+    anchorClassName = _ref.anchorClassName;
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isOpen = _useState2[0],
+    setIsOpen = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    loading = _useState4[0],
+    setLoading = _useState4[1];
+  var _useState5 = useState(null),
+    _useState6 = _slicedToArray(_useState5, 2),
+    activeKey = _useState6[0],
+    setActiveKey = _useState6[1];
+  var _useState7 = useState(null),
+    _useState8 = _slicedToArray(_useState7, 2),
+    resolution = _useState8[0],
+    setResolution = _useState8[1];
+  var _useState9 = useState([]),
+    _useState10 = _slicedToArray(_useState9, 2),
+    options = _useState10[0],
+    setOptions = _useState10[1];
+  var _useState11 = useState({
+      x: 0,
+      y: 0
+    }),
+    _useState12 = _slicedToArray(_useState11, 2),
+    dropdownPosition = _useState12[0],
+    setDropdownPosition = _useState12[1];
+  var cancelRef = useRef({
+    cancel: function cancel() {}
+  });
+  var triggerMapRef = useRef(new Map());
+  var close = useCallback(function () {
+    setIsOpen(false);
+    setOptions([]);
+    setResolution(null);
+    setActiveKey(null);
+  }, []);
+  var handleActiveKeyChange = useCallback(function (key) {
+    setActiveKey(key);
+  }, []);
+  useLayoutEffect(function () {
+    var _Children$map;
+    var options = ((_Children$map = Children.map(children, function (child) {
+      if (!child) return null;
+      var option = child.props;
+      triggerMapRef.current.set(option.trigger, option);
+      return option;
+    })) === null || _Children$map === void 0 ? void 0 : _Children$map.filter(Boolean)) || [];
+    editor.registerPlugin(SlashPlugin, {
+      slashOptions: options,
+      triggerClose: function triggerClose() {
+        close();
+        cancelRef.current.cancel();
+      },
+      triggerOpen: function triggerOpen(ctx) {
+        setResolution(ctx);
+        cancelRef.current.cancel();
+        if (Array.isArray(ctx.items)) {
+          setOptions(ctx.items);
+          if (!activeKey) {
+            var _ctx$items;
+            // @ts-ignore
+            setActiveKey((_ctx$items = ctx.items) === null || _ctx$items === void 0 || (_ctx$items = _ctx$items[0]) === null || _ctx$items === void 0 ? void 0 : _ctx$items.key);
+          }
+        } else {
+          setLoading(true);
+          var pr = setCancelablePromise(function (resolve, reject) {
+            ctx
+            // @ts-ignore
+            .items(ctx.match || null).then(resolve, reject).finally(function () {
+              return setLoading(false);
+            });
+          });
+          pr.promise.then(function (items) {
+            var typedItems = items;
+            setOptions(typedItems);
+            if (!activeKey) {
+              var _typedItems$;
+              // @ts-ignore
+              setActiveKey(typedItems === null || typedItems === void 0 || (_typedItems$ = typedItems[0]) === null || _typedItems$ === void 0 ? void 0 : _typedItems$.key);
+            }
+          });
+          cancelRef.current.cancel = function () {
+            pr.cancel();
+            setLoading(false);
+          };
+        }
+        var rect = ctx.getRect();
+        setDropdownPosition({
+          x: rect.left,
+          y: rect.bottom
+        });
+        setIsOpen(true);
+      }
+    });
+  }, [activeKey, editor, close]);
+  var handleMenuSelect = useCallback(function (option) {
+    // ISlashMenuOption should not have divider type, but adding check for safety
+    if ('type' in option && option.type === 'divider') {
+      return;
+    }
+    var lexicalEditor = editor.getLexicalEditor();
+    if (lexicalEditor && resolution) {
+      lexicalEditor.update(function () {
+        var _option$onSelect;
+        var textNodeContainingQuery = resolution.match ? $splitNodeContainingQuery(resolution.match) : null;
+        textNodeContainingQuery === null || textNodeContainingQuery === void 0 || textNodeContainingQuery.remove();
+        (_option$onSelect = option.onSelect) === null || _option$onSelect === void 0 || _option$onSelect.call(option, editor, resolution.match ? resolution.match.matchingString : '');
+      });
+    }
+    var currentTriggerProps = triggerMapRef.current.get((resolution === null || resolution === void 0 ? void 0 : resolution.trigger) || '');
+
+    // Call the external unified onSelect first if it exists
+    if (currentTriggerProps !== null && currentTriggerProps !== void 0 && currentTriggerProps.onSelect) {
+      currentTriggerProps.onSelect(editor, option);
+    }
+    close();
+  }, [editor, resolution, close]);
+  useLexicalEditor(function (editor) {
+    var pureOptions = options.filter(function (item) {
+      return !('type' in item && item.type === 'divider') && 'key' in item && Boolean(item.key);
+    });
+    return mergeRegister(editor.registerCommand(KEY_ARROW_DOWN_COMMAND, function (payload) {
+      var event = payload;
+      if (pureOptions !== null && pureOptions.length) {
+        var currentIndex = activeKey ? pureOptions.findIndex(function (opt) {
+          return opt.key === activeKey;
+        }) : -1;
+        var newIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % pureOptions.length;
+        setActiveKey(String(pureOptions[newIndex].key));
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+      return true;
+    }, COMMAND_PRIORITY_NORMAL), editor.registerCommand(KEY_ARROW_UP_COMMAND, function (payload) {
+      var event = payload;
+      if (pureOptions !== null && pureOptions.length) {
+        var currentIndex = activeKey ? pureOptions.findIndex(function (opt) {
+          return opt.key === activeKey;
+        }) : -1;
+        var newIndex = currentIndex === -1 ? pureOptions.length - 1 : (currentIndex - 1 + pureOptions.length) % pureOptions.length;
+        setActiveKey(String(pureOptions[newIndex].key));
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+      return true;
+    }, COMMAND_PRIORITY_NORMAL), editor.registerCommand(KEY_ESCAPE_COMMAND, function (payload) {
+      var event = payload;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      close();
+      return true;
+    }, COMMAND_PRIORITY_NORMAL), editor.registerCommand(KEY_TAB_COMMAND, function (payload) {
+      var event = payload;
+      if (options === null || activeKey === null) {
+        return false;
+      }
+      var selectedOption = options.find(function (opt) {
+        return 'key' in opt && opt.key === activeKey;
+      });
+      if (!selectedOption) {
+        return false;
+      }
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      handleMenuSelect(selectedOption);
+      return true;
+    }, COMMAND_PRIORITY_NORMAL), editor.registerCommand(KEY_ENTER_COMMAND, function (event) {
+      if (options === null || activeKey === null) {
+        return false;
+      }
+      var selectedOption = options.find(function (opt) {
+        return 'key' in opt && opt.key === activeKey;
+      });
+      if (!selectedOption) {
+        return false;
+      }
+      if (event !== null) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+      handleMenuSelect(selectedOption);
+      return true;
+    }, COMMAND_PRIORITY_NORMAL));
+  }, [options, activeKey, handleActiveKeyChange, handleMenuSelect]);
+
+  // Get custom render component if available
+  var _ref2 = triggerMapRef.current.get((resolution === null || resolution === void 0 ? void 0 : resolution.trigger) || '') || {},
+    CustomRender = _ref2.renderComp;
+  return /*#__PURE__*/_jsx(SlashMenu, {
+    activeKey: activeKey,
+    anchorClassName: anchorClassName,
+    customRender: CustomRender,
+    loading: loading,
+    onActiveKeyChange: handleActiveKeyChange,
+    onClose: close,
+    onSelect: handleMenuSelect,
+    open: isOpen,
+    options: options,
+    position: dropdownPosition
+  });
+};
+ReactSlashPlugin.displayName = 'ReactSlashPlugin';
+export default ReactSlashPlugin;

package/es/plugins/slash/react/components/SlashMenu.d.ts

@@ -0,0 +1,8 @@
+import { type FC } from 'react';
+import type { SlashMenuProps } from '../type';
+/**
+ * SlashMenu component - Only responsible for rendering the menu UI
+ * All state management and plugin registration is handled by ReactSlashPlugin
+ */
+declare const SlashMenu: FC<SlashMenuProps>;
+export default SlashMenu;

package/es/plugins/slash/react/components/SlashMenu.js

@@ -0,0 +1,72 @@
+'use client';
+
+import { Dropdown } from '@lobehub/ui';
+import { useCallback } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * SlashMenu component - Only responsible for rendering the menu UI
+ * All state management and plugin registration is handled by ReactSlashPlugin
+ */
+var SlashMenu = function SlashMenu(_ref) {
+  var activeKey = _ref.activeKey,
+    anchorClassName = _ref.anchorClassName,
+    CustomRender = _ref.customRender,
+    loading = _ref.loading,
+    onActiveKeyChange = _ref.onActiveKeyChange,
+    onSelect = _ref.onSelect,
+    open = _ref.open,
+    options = _ref.options,
+    position = _ref.position,
+    _onClose = _ref.onClose;
+  // Adapter for custom render component onSelect
+  var customRenderOnSelect = useCallback(function (option) {
+    onSelect(option);
+  }, [onSelect]);
+  var handleMenuClick = useCallback(function (_ref2) {
+    var key = _ref2.key;
+    var option = options.find(function (item) {
+      return 'key' in item && item.key === key;
+    });
+    if (option) onSelect(option);
+  }, [options, onSelect]);
+
+  /**
+   * Render the custom component if it exists
+   */
+  if (CustomRender) {
+    return /*#__PURE__*/_jsx(CustomRender, {
+      activeKey: activeKey,
+      loading: loading,
+      onSelect: customRenderOnSelect,
+      open: open,
+      options: options,
+      setActiveKey: onActiveKeyChange
+    });
+  }
+  return /*#__PURE__*/_jsx("div", {
+    style: {
+      left: position.x,
+      position: 'fixed',
+      top: position.y,
+      zIndex: 1050
+    },
+    children: /*#__PURE__*/_jsx(Dropdown, {
+      menu: {
+        // @ts-ignore
+        activeKey: activeKey,
+        items: loading ? [{
+          disabled: true,
+          key: 'loading',
+          label: 'Loading...'
+        }] : options,
+        onClick: handleMenuClick
+      },
+      open: open,
+      children: /*#__PURE__*/_jsx("span", {
+        className: anchorClassName
+      })
+    })
+  });
+};
+SlashMenu.displayName = 'SlashMenu';
+export default SlashMenu;

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

@@ -0,0 +1,4 @@
+export { default as SlashMenu } from './components/SlashMenu';
+export { default as ReactSlashOption } from './ReactSlashOption';
+export { default as ReactSlashPlugin } from './ReactSlashPlugin';
+export type * from './type';

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

@@ -0,0 +1,3 @@
+export { default as SlashMenu } from "./components/SlashMenu";
+export { default as ReactSlashOption } from "./ReactSlashOption";
+export { default as ReactSlashPlugin } from "./ReactSlashPlugin";

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

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

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

@@ -0,0 +1,9 @@
+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 css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    background: ", ";\n  "])), token.colorBgElevated);
+});

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

@@ -0,0 +1,82 @@
+import type { FC, ReactElement } from 'react';
+import type { SlashOptions } from "..";
+import type { ISlashMenuOption, ISlashOption } from "../service/i-slash-service";
+import type { IEditor } from "../../../types";
+export interface ReactSlashOptionProps {
+    /**
+     * Searchable options
+     */
+    items?: SlashOptions['items'];
+    /**
+     * Maximum search length
+     * Default is 75
+     */
+    maxLength?: number;
+    onSelect?: (editor: IEditor, option: ISlashMenuOption) => void;
+    /**
+     * Custom render component
+     */
+    renderComp?: FC<MenuRenderProps>;
+    /**
+     * Trigger character
+     */
+    trigger?: SlashOptions['trigger'];
+}
+export interface MenuRenderProps {
+    /**
+     * Current active option key
+     */
+    activeKey: string | null;
+    /**
+     * Loading state
+     */
+    loading?: boolean;
+    /**
+     * Actively trigger selection
+     * @param option Currently selected element
+     */
+    onSelect?: (option: ISlashMenuOption) => void;
+    open?: boolean;
+    /**
+     * Currently searched options
+     */
+    options: Array<ISlashOption>;
+    /**
+     * Actively set current active option key
+     * @param key
+     * @returns
+     */
+    setActiveKey: (key: string | null) => void;
+}
+/**
+ * SlashMenu component props - only responsible for rendering
+ */
+export interface SlashMenuProps {
+    /** Current active option key */
+    activeKey: string | null;
+    /** Anchor element className */
+    anchorClassName?: string;
+    /** Custom render component if provided */
+    customRender?: FC<MenuRenderProps>;
+    /** Loading state */
+    loading: boolean;
+    /** Callback to set active key */
+    onActiveKeyChange: (key: string | null) => void;
+    /** Callback when menu should close */
+    onClose: () => void;
+    /** Callback when an option is selected */
+    onSelect: (option: ISlashMenuOption) => void;
+    /** Whether the menu is open */
+    open: boolean;
+    /** Available options to display */
+    options: Array<ISlashOption>;
+    /** Menu position */
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export interface ReactSlashPluginProps {
+    anchorClassName?: string;
+    children?: (ReactElement<ReactSlashOptionProps> | undefined) | (ReactElement<ReactSlashOptionProps> | undefined)[];
+}

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

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

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

@@ -0,0 +1,5 @@
+export type CancelablePromise<T> = {
+    cancel: () => void;
+    promise: Promise<T>;
+};
+export declare function setCancelablePromise<T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): CancelablePromise<T>;

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

@@ -0,0 +1,20 @@
+export function setCancelablePromise(executor) {
+  var isCancelled = false;
+  var promise = new Promise(function (resolve, reject) {
+    executor(function (value) {
+      if (!isCancelled) {
+        resolve(value);
+      }
+    }, function (reason) {
+      if (!isCancelled) {
+        reject(reason);
+      }
+    });
+  });
+  return {
+    cancel: function cancel() {
+      isCancelled = true;
+    },
+    promise: promise
+  };
+}

package/es/plugins/slash/service/i-slash-service.d.ts

@@ -0,0 +1,38 @@
+import { DropdownMenuItemType } from '@lobehub/ui';
+import Fuse from 'fuse.js';
+import type { IEditor, IEditorKernel, IServiceID } from "../../../types";
+import { getBasicTypeaheadTriggerMatch } from '../utils/utils';
+export type ISlashDividerOption = {
+    type: 'divider';
+};
+export interface ISlashMenuOption extends DropdownMenuItemType {
+    onSelect?: (editor: IEditor, matchingString: string) => void;
+}
+export type ISlashOption = ISlashMenuOption | ISlashDividerOption;
+export interface SlashOptions {
+    allowWhitespace?: boolean;
+    items: Array<ISlashOption> | ((search: {
+        leadOffset: number;
+        matchingString: string;
+        replaceableString: string;
+    } | null) => Promise<Array<ISlashOption>>);
+    maxLength?: number;
+    minLength?: number;
+    punctuation?: string;
+    trigger: string;
+}
+export interface ISlashService {
+    registerSlash(options: SlashOptions): void;
+}
+export declare const ISlashService: IServiceID<ISlashService>;
+export declare class SlashService implements ISlashService {
+    private kernel;
+    private triggerMap;
+    private triggerFnMap;
+    private triggerFuseMap;
+    constructor(kernel: IEditorKernel);
+    registerSlash(options: SlashOptions): void;
+    getSlashOptions(trigger: string): SlashOptions | undefined;
+    getSlashTriggerFn(trigger: string): ReturnType<typeof getBasicTypeaheadTriggerMatch> | undefined;
+    getSlashFuse(trigger: string): Fuse<ISlashOption> | undefined;
+}

package/es/plugins/slash/service/i-slash-service.js

@@ -0,0 +1,64 @@
+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 _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 no-redeclare */
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import Fuse from 'fuse.js';
+import { genServiceId } from "../../../editor-kernel";
+import { getBasicTypeaheadTriggerMatch } from "../utils/utils";
+export var ISlashService = genServiceId('SlashService');
+export var SlashService = /*#__PURE__*/function () {
+  function SlashService(kernel) {
+    _classCallCheck(this, SlashService);
+    _defineProperty(this, "triggerMap", new Map());
+    _defineProperty(this, "triggerFnMap", new Map());
+    _defineProperty(this, "triggerFuseMap", new Map());
+    this.kernel = kernel;
+  }
+  // Specific service methods can be added here
+  _createClass(SlashService, [{
+    key: "registerSlash",
+    value: function registerSlash(options) {
+      if (this.triggerMap.has(options.trigger)) {
+        throw new Error("Slash trigger \"".concat(options.trigger, "\" is already registered."));
+      }
+      this.triggerMap.set(options.trigger, options);
+      this.triggerFnMap.set(options.trigger, getBasicTypeaheadTriggerMatch(options.trigger, {
+        allowWhitespace: options.allowWhitespace,
+        maxLength: options.maxLength,
+        minLength: options.minLength,
+        punctuation: options.punctuation
+      }));
+      if (Array.isArray(options.items)) {
+        // Filter out divider items for search functionality
+        var searchableItems = options.items.filter(function (item) {
+          return !('type' in item) || item.type !== 'divider';
+        });
+        this.triggerFuseMap.set(options.trigger, new Fuse(searchableItems, {
+          keys: ['label', 'value']
+        }));
+      }
+    }
+  }, {
+    key: "getSlashOptions",
+    value: function getSlashOptions(trigger) {
+      return this.triggerMap.get(trigger);
+    }
+  }, {
+    key: "getSlashTriggerFn",
+    value: function getSlashTriggerFn(trigger) {
+      return this.triggerFnMap.get(trigger);
+    }
+  }, {
+    key: "getSlashFuse",
+    value: function getSlashFuse(trigger) {
+      return this.triggerFuseMap.get(trigger);
+    }
+  }]);
+  return SlashService;
+}();

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

@@ -0,0 +1,38 @@
+import { LexicalEditor, RangeSelection, TextNode } from 'lexical';
+/**
+ * Get the text content of the editor up to the anchor point of the selection.
+ * Get the text content before the anchor point of the selection
+ * @param selection Selection object from Lexical editor
+ * @returns
+ */
+export declare function getTextUpToAnchor(selection: RangeSelection): string | null;
+/**
+ *
+ * @param editor Lexical editor instance
+ * Get the text content before the selection anchor point in the editor
+ * @returns
+ */
+export declare function getQueryTextForSearch(editor: LexicalEditor): string | null;
+export declare function tryToPositionRange(leadOffset: number, range: Range, editorWindow: Window): boolean;
+export declare function getScrollParent(element: HTMLElement, includeHidden: boolean): HTMLElement | HTMLBodyElement;
+export declare const scrollIntoViewIfNeeded: (target: HTMLElement) => void;
+export declare const PUNCTUATION = "\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'\"~=<>_:;";
+export declare function getBasicTypeaheadTriggerMatch(trigger: string, { minLength, maxLength, punctuation, allowWhitespace, }: {
+    allowWhitespace?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    punctuation?: string;
+}): (text: string) => {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+} | null;
+/**
+ * Split Lexical TextNode and return a new TextNode only containing matched text.
+ * Common use cases include: removing the node, replacing with a new node.
+ */
+export declare function $splitNodeContainingQuery(match: {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+}): TextNode | null;