@ruya.sa/richtext-lexical 3.71.7

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js

@@ -0,0 +1,180 @@
+'use client';
+
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_LOW, createCommand, getDOMSelection } from 'lexical';
+import { useCallback, useEffect, useState } from 'react';
+import * as React from 'react';
+import { LexicalMenu, useMenuAnchorRef } from './LexicalMenu.js';
+export const PUNCTUATION = '\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%\'"~=<>_:;';
+function getTextUpToAnchor(selection) {
+  const anchor = selection.anchor;
+  if (anchor.type !== 'text') {
+    return null;
+  }
+  const anchorNode = anchor.getNode();
+  if (!anchorNode.isSimpleText()) {
+    return null;
+  }
+  const anchorOffset = anchor.offset;
+  return anchorNode.getTextContent().slice(0, anchorOffset);
+}
+function tryToPositionRange(leadOffset, range, editorWindow) {
+  const domSelection = getDOMSelection(editorWindow);
+  if (domSelection === null || !domSelection.isCollapsed) {
+    return false;
+  }
+  const anchorNode = domSelection.anchorNode;
+  const startOffset = leadOffset;
+  const endOffset = domSelection.anchorOffset;
+  if (anchorNode == null || endOffset == null) {
+    return false;
+  }
+  try {
+    range.setStart(anchorNode, startOffset);
+    // if endOffset is 0, positioning the range for when you click the plus button to open the slash menu will fial
+    range.setEnd(anchorNode, endOffset > 1 ? endOffset : 1);
+  } catch (error) {
+    return false;
+  }
+  return true;
+}
+function getQueryTextForSearch(editor) {
+  let text;
+  editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection)) {
+      return;
+    }
+    text = getTextUpToAnchor(selection);
+  });
+  return text;
+}
+function isSelectionOnEntityBoundary(editor, offset) {
+  if (offset !== 0) {
+    return false;
+  }
+  return editor.getEditorState().read(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+      const anchor = selection.anchor;
+      const anchorNode = anchor.getNode();
+      const prevSibling = anchorNode.getPreviousSibling();
+      return $isTextNode(prevSibling) && prevSibling.isTextEntity();
+    }
+    return false;
+  });
+}
+function startTransition(callback) {
+  if (React.startTransition) {
+    React.startTransition(callback);
+  } else {
+    callback();
+  }
+}
+export { useDynamicPositioning } from './LexicalMenu.js';
+export const ENABLE_SLASH_MENU_COMMAND = createCommand('ENABLE_SLASH_MENU_COMMAND');
+export function LexicalTypeaheadMenuPlugin({
+  anchorClassName,
+  anchorElem,
+  groups,
+  menuRenderFn,
+  onClose,
+  onOpen,
+  onQueryChange,
+  triggerFn
+}) {
+  const [editor] = useLexicalComposerContext();
+  const [resolution, setResolution] = useState(null);
+  const anchorElementRef = useMenuAnchorRef(anchorElem, resolution, setResolution, anchorClassName);
+  const closeTypeahead = useCallback(() => {
+    setResolution(null);
+    if (onClose != null && resolution !== null) {
+      onClose();
+    }
+  }, [onClose, resolution]);
+  const openTypeahead = useCallback(res => {
+    setResolution(res);
+    if (onOpen != null && resolution === null) {
+      onOpen(res);
+    }
+  }, [onOpen, resolution]);
+  // This is mainly used for the AddBlockHandlePlugin, so that the slash menu can be opened from there
+  useEffect(() => {
+    return mergeRegister(editor.registerCommand(ENABLE_SLASH_MENU_COMMAND, ({
+      node
+    }) => {
+      editor.getEditorState().read(() => {
+        const match = {
+          leadOffset: 0,
+          matchingString: '',
+          replaceableString: ''
+        };
+        if (!isSelectionOnEntityBoundary(editor, match.leadOffset)) {
+          if (node !== null) {
+            const editorWindow = editor._window ?? window;
+            const range = editorWindow.document.createRange();
+            const isRangePositioned = tryToPositionRange(match.leadOffset, range, editorWindow);
+            if (isRangePositioned !== null) {
+              startTransition(() => openTypeahead({
+                getRect: () => {
+                  return range.getBoundingClientRect();
+                },
+                match
+              }));
+            }
+            return;
+          }
+        }
+      });
+      return true;
+    }, COMMAND_PRIORITY_LOW));
+  }, [editor, openTypeahead]);
+  useEffect(() => {
+    const updateListener = () => {
+      editor.getEditorState().read(() => {
+        const editorWindow_0 = editor._window ?? window;
+        const range_0 = editorWindow_0.document.createRange();
+        const selection = $getSelection();
+        const text = getQueryTextForSearch(editor);
+        if (!$isRangeSelection(selection) || !selection.isCollapsed() || text === undefined || range_0 === null) {
+          closeTypeahead();
+          return;
+        }
+        const match_0 = triggerFn({
+          editor,
+          query: text
+        });
+        onQueryChange(match_0 ? match_0.matchingString : null);
+        if (match_0 !== null && !isSelectionOnEntityBoundary(editor, match_0.leadOffset)) {
+          const isRangePositioned_0 = tryToPositionRange(match_0.leadOffset, range_0, editorWindow_0);
+          if (isRangePositioned_0 !== null) {
+            startTransition(() => openTypeahead({
+              getRect: () => {
+                return range_0.getBoundingClientRect();
+              },
+              match: match_0
+            }));
+            return;
+          }
+        }
+        closeTypeahead();
+      });
+    };
+    const removeUpdateListener = editor.registerUpdateListener(updateListener);
+    return () => {
+      removeUpdateListener();
+    };
+  }, [editor, triggerFn, onQueryChange, resolution, closeTypeahead, openTypeahead]);
+  return anchorElementRef.current === null || resolution === null || editor === null ? null : /*#__PURE__*/_jsx(LexicalMenu, {
+    anchorElementRef: anchorElementRef,
+    close: closeTypeahead,
+    editor: editor,
+    groups: groups,
+    menuRenderFn: menuRenderFn,
+    resolution: resolution,
+    shouldSplitNodeWithQuery: true
+  });
+}
+//# sourceMappingURL=index.js.map

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["useLexicalComposerContext","mergeRegister","$getSelection","$isRangeSelection","$isTextNode","COMMAND_PRIORITY_LOW","createCommand","getDOMSelection","useCallback","useEffect","useState","React","LexicalMenu","useMenuAnchorRef","PUNCTUATION","getTextUpToAnchor","selection","anchor","type","anchorNode","getNode","isSimpleText","anchorOffset","offset","getTextContent","slice","tryToPositionRange","leadOffset","range","editorWindow","domSelection","isCollapsed","startOffset","endOffset","setStart","setEnd","error","getQueryTextForSearch","editor","text","getEditorState","read","isSelectionOnEntityBoundary","prevSibling","getPreviousSibling","isTextEntity","startTransition","callback","useDynamicPositioning","ENABLE_SLASH_MENU_COMMAND","LexicalTypeaheadMenuPlugin","anchorClassName","anchorElem","groups","menuRenderFn","onClose","onOpen","onQueryChange","triggerFn","resolution","setResolution","anchorElementRef","closeTypeahead","openTypeahead","res","registerCommand","node","match","matchingString","replaceableString","_window","window","document","createRange","isRangePositioned","getRect","getBoundingClientRect","updateListener","undefined","query","removeUpdateListener","registerUpdateListener","current","_jsx","close","shouldSplitNodeWithQuery"],"sources":["../../../../../src/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.tsx"],"sourcesContent":["'use client'\nimport type { LexicalCommand, LexicalEditor, ParagraphNode, RangeSelection } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { mergeRegister } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isRangeSelection,\n  $isTextNode,\n  COMMAND_PRIORITY_LOW,\n  createCommand,\n  getDOMSelection,\n} from 'lexical'\nimport { type JSX, useCallback, useEffect, useState } from 'react'\nimport * as React from 'react'\n\nimport type { MenuTextMatch, TriggerFn } from '../useMenuTriggerMatch.js'\nimport type { MenuRenderFn, MenuResolution } from './LexicalMenu.js'\nimport type { SlashMenuGroupInternal } from './types.js'\n\nimport { LexicalMenu, useMenuAnchorRef } from './LexicalMenu.js'\n\nexport const PUNCTUATION = '\\\\.,\\\\+\\\\*\\\\?\\\\$\\\\@\\\\|#{}\\\\(\\\\)\\\\^\\\\-\\\\[\\\\]\\\\\\\\/!%\\'\"~=<>_:;'\n\nfunction getTextUpToAnchor(selection: RangeSelection): null | string {\n  const anchor = selection.anchor\n  if (anchor.type !== 'text') {\n    return null\n  }\n  const anchorNode = anchor.getNode()\n  if (!anchorNode.isSimpleText()) {\n    return null\n  }\n  const anchorOffset = anchor.offset\n  return anchorNode.getTextContent().slice(0, anchorOffset)\n}\n\nfunction tryToPositionRange(leadOffset: number, range: Range, editorWindow: Window): boolean {\n  const domSelection = getDOMSelection(editorWindow)\n  if (domSelection === null || !domSelection.isCollapsed) {\n    return false\n  }\n\n  const anchorNode = domSelection.anchorNode\n  const startOffset = leadOffset\n  const endOffset = domSelection.anchorOffset\n\n  if (anchorNode == null || endOffset == null) {\n    return false\n  }\n\n  try {\n    range.setStart(anchorNode, startOffset)\n    // if endOffset is 0, positioning the range for when you click the plus button to open the slash menu will fial\n    range.setEnd(anchorNode, endOffset > 1 ? endOffset : 1)\n  } catch (error) {\n    return false\n  }\n\n  return true\n}\n\nfunction getQueryTextForSearch(editor: LexicalEditor): string | undefined {\n  let text\n  editor.getEditorState().read(() => {\n    const selection = $getSelection()\n    if (!$isRangeSelection(selection)) {\n      return\n    }\n    text = getTextUpToAnchor(selection)\n  })\n  return text\n}\n\nfunction isSelectionOnEntityBoundary(editor: LexicalEditor, offset: number): boolean {\n  if (offset !== 0) {\n    return false\n  }\n  return editor.getEditorState().read(() => {\n    const selection = $getSelection()\n    if ($isRangeSelection(selection)) {\n      const anchor = selection.anchor\n      const anchorNode = anchor.getNode()\n      const prevSibling = anchorNode.getPreviousSibling()\n      return $isTextNode(prevSibling) && prevSibling.isTextEntity()\n    }\n    return false\n  })\n}\n\nfunction startTransition(callback: () => void) {\n  if (React.startTransition) {\n    React.startTransition(callback)\n  } else {\n    callback()\n  }\n}\n\nexport { useDynamicPositioning } from './LexicalMenu.js'\n\nexport type TypeaheadMenuPluginProps = {\n  anchorClassName?: string\n  anchorElem: HTMLElement\n  groups: Array<SlashMenuGroupInternal>\n  menuRenderFn: MenuRenderFn\n  onClose?: () => void\n  onOpen?: (resolution: MenuResolution) => void\n  onQueryChange: (matchingString: null | string) => void\n  triggerFn: TriggerFn\n}\n\nexport const ENABLE_SLASH_MENU_COMMAND: LexicalCommand<{\n  node: ParagraphNode\n}> = createCommand('ENABLE_SLASH_MENU_COMMAND')\n\nexport function LexicalTypeaheadMenuPlugin({\n  anchorClassName,\n  anchorElem,\n  groups,\n  menuRenderFn,\n  onClose,\n  onOpen,\n  onQueryChange,\n  triggerFn,\n}: TypeaheadMenuPluginProps): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n  const [resolution, setResolution] = useState<MenuResolution | null>(null)\n  const anchorElementRef = useMenuAnchorRef(anchorElem, resolution, setResolution, anchorClassName)\n\n  const closeTypeahead = useCallback(() => {\n    setResolution(null)\n    if (onClose != null && resolution !== null) {\n      onClose()\n    }\n  }, [onClose, resolution])\n\n  const openTypeahead = useCallback(\n    (res: MenuResolution) => {\n      setResolution(res)\n      if (onOpen != null && resolution === null) {\n        onOpen(res)\n      }\n    },\n    [onOpen, resolution],\n  )\n\n  // This is mainly used for the AddBlockHandlePlugin, so that the slash menu can be opened from there\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerCommand(\n        ENABLE_SLASH_MENU_COMMAND,\n        ({ node }) => {\n          editor.getEditorState().read(() => {\n            const match: MenuTextMatch = {\n              leadOffset: 0,\n              matchingString: '',\n              replaceableString: '',\n            }\n            if (!isSelectionOnEntityBoundary(editor, match.leadOffset)) {\n              if (node !== null) {\n                const editorWindow = editor._window ?? window\n                const range = editorWindow.document.createRange()\n\n                const isRangePositioned = tryToPositionRange(match.leadOffset, range, editorWindow)\n                if (isRangePositioned !== null) {\n                  startTransition(() =>\n                    openTypeahead({\n                      getRect: () => {\n                        return range.getBoundingClientRect()\n                      },\n                      match,\n                    }),\n                  )\n                }\n\n                return\n              }\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, openTypeahead])\n\n  useEffect(() => {\n    const updateListener = () => {\n      editor.getEditorState().read(() => {\n        const editorWindow = editor._window ?? window\n        const range = editorWindow.document.createRange()\n        const selection = $getSelection()\n        const text = getQueryTextForSearch(editor)\n\n        if (\n          !$isRangeSelection(selection) ||\n          !selection.isCollapsed() ||\n          text === undefined ||\n          range === null\n        ) {\n          closeTypeahead()\n          return\n        }\n\n        const match = triggerFn({ editor, query: text })\n        onQueryChange(match ? match.matchingString : null)\n\n        if (match !== null && !isSelectionOnEntityBoundary(editor, match.leadOffset)) {\n          const isRangePositioned = tryToPositionRange(match.leadOffset, range, editorWindow)\n          if (isRangePositioned !== null) {\n            startTransition(() =>\n              openTypeahead({\n                getRect: () => {\n                  return range.getBoundingClientRect()\n                },\n                match,\n              }),\n            )\n            return\n          }\n        }\n        closeTypeahead()\n      })\n    }\n\n    const removeUpdateListener = editor.registerUpdateListener(updateListener)\n\n    return () => {\n      removeUpdateListener()\n    }\n  }, [editor, triggerFn, onQueryChange, resolution, closeTypeahead, openTypeahead])\n\n  return anchorElementRef.current === null || resolution === null || editor === null ? null : (\n    <LexicalMenu\n      anchorElementRef={anchorElementRef}\n      close={closeTypeahead}\n      editor={editor}\n      groups={groups}\n      menuRenderFn={menuRenderFn}\n      resolution={resolution}\n      shouldSplitNodeWithQuery\n    />\n  )\n}\n\nexport type { MenuRenderFn, MenuResolution, MenuTextMatch, TriggerFn }\n"],"mappings":"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","ignoreList":[]}

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.d.ts

@@ -0,0 +1,51 @@
+import type { I18nClient } from '@ruya.sa/translations';
+import type { LexicalEditor, Spread } from 'lexical';
+import type React from 'react';
+import type { RefObject } from 'react';
+import type { FeatureClientSchemaMap } from '../../../../types.js';
+export type SlashMenuItem = {
+    /** The icon which is rendered in your slash menu item. */
+    Icon: React.FC;
+    /** Each slash menu item needs to have a unique key. The key will be matched when typing, displayed if no `label` property is set, and used for classNames. */
+    key: string;
+    /**
+     * Keywords are used to match the item for different texts typed after the '/'.
+     * E.g. you might want to show a horizontal rule item if you type both /hr, /separator, /horizontal etc.
+     * In addition to the keywords, the label and key will be used to find the right slash menu item.
+     */
+    keywords?: Array<string>;
+    /** The label will be displayed in your slash menu item. In order to make use of i18n, this can be a function. */
+    label?: ((args: {
+        featureClientSchemaMap: FeatureClientSchemaMap;
+        i18n: I18nClient<{}, string>;
+        schemaPath: string;
+    }) => string) | string;
+    /** A function which is called when the slash menu item is selected. */
+    onSelect: ({ editor, queryString }: {
+        editor: LexicalEditor;
+        queryString: string;
+    }) => void;
+};
+export type SlashMenuGroup = {
+    /**
+     * An array of `SlashMenuItem`'s which will be displayed in the slash menu.
+     */
+    items: Array<SlashMenuItem>;
+    /**
+     * Used for class names and, if label is not provided, for display. Slash menus with the same key will have their items merged together.
+     */
+    key: string;
+    /** The label will be displayed before your Slash Menu group. In order to make use of i18n, this can be a function. */
+    label?: ((args: {
+        featureClientSchemaMap: FeatureClientSchemaMap;
+        i18n: I18nClient<{}, string>;
+        schemaPath: string;
+    }) => string) | string;
+};
+export type SlashMenuItemInternal = {
+    ref: RefObject<HTMLButtonElement | null>;
+} & SlashMenuItem;
+export type SlashMenuGroupInternal = Spread<{
+    items: Array<SlashMenuItemInternal>;
+}, SlashMenuGroup>;
+//# sourceMappingURL=types.d.ts.map

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAElE,MAAM,MAAM,aAAa,GAAG;IAC1B,0DAA0D;IAC1D,IAAI,EAAE,KAAK,CAAC,EAAE,CAAA;IACd,8JAA8J;IAC9J,GAAG,EAAE,MAAM,CAAA;IACX;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACxB,iHAAiH;IACjH,KAAK,CAAC,EACF,CAAC,CAAC,IAAI,EAAE;QACN,sBAAsB,EAAE,sBAAsB,CAAA;QAC9C,IAAI,EAAE,UAAU,CAAC,EAAE,EAAE,MAAM,CAAC,CAAA;QAC5B,UAAU,EAAE,MAAM,CAAA;KACnB,KAAK,MAAM,CAAC,GACb,MAAM,CAAA;IACV,uEAAuE;IACvE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CAC5F,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;IAC3B;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;IACX,sHAAsH;IACtH,KAAK,CAAC,EACF,CAAC,CAAC,IAAI,EAAE;QACN,sBAAsB,EAAE,sBAAsB,CAAA;QAC9C,IAAI,EAAE,UAAU,CAAC,EAAE,EAAE,MAAM,CAAC,CAAA;QAC5B,UAAU,EAAE,MAAM,CAAA;KACnB,KAAK,MAAM,CAAC,GACb,MAAM,CAAA;CACX,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAA;CACzC,GAAG,aAAa,CAAA;AAEjB,MAAM,MAAM,sBAAsB,GAAG,MAAM,CACzC;IACE,KAAK,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAA;CACpC,EACD,cAAc,CACf,CAAA"}

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.ts"],"sourcesContent":["import type { I18nClient } from '@ruya.sa/translations'\nimport type { LexicalEditor, Spread } from 'lexical'\nimport type React from 'react'\nimport type { RefObject } from 'react'\n\nimport type { FeatureClientSchemaMap } from '../../../../types.js'\n\nexport type SlashMenuItem = {\n  /** The icon which is rendered in your slash menu item. */\n  Icon: React.FC\n  /** Each slash menu item needs to have a unique key. The key will be matched when typing, displayed if no `label` property is set, and used for classNames. */\n  key: string\n  /**\n   * Keywords are used to match the item for different texts typed after the '/'.\n   * E.g. you might want to show a horizontal rule item if you type both /hr, /separator, /horizontal etc.\n   * In addition to the keywords, the label and key will be used to find the right slash menu item.\n   */\n  keywords?: Array<string>\n  /** The label will be displayed in your slash menu item. In order to make use of i18n, this can be a function. */\n  label?:\n    | ((args: {\n        featureClientSchemaMap: FeatureClientSchemaMap\n        i18n: I18nClient<{}, string>\n        schemaPath: string\n      }) => string)\n    | string\n  /** A function which is called when the slash menu item is selected. */\n  onSelect: ({ editor, queryString }: { editor: LexicalEditor; queryString: string }) => void\n}\n\nexport type SlashMenuGroup = {\n  /**\n   * An array of `SlashMenuItem`'s which will be displayed in the slash menu.\n   */\n  items: Array<SlashMenuItem>\n  /**\n   * Used for class names and, if label is not provided, for display. Slash menus with the same key will have their items merged together.\n   */\n  key: string\n  /** The label will be displayed before your Slash Menu group. In order to make use of i18n, this can be a function. */\n  label?:\n    | ((args: {\n        featureClientSchemaMap: FeatureClientSchemaMap\n        i18n: I18nClient<{}, string>\n        schemaPath: string\n      }) => string)\n    | string\n}\n\nexport type SlashMenuItemInternal = {\n  ref: RefObject<HTMLButtonElement | null>\n} & SlashMenuItem\n\nexport type SlashMenuGroupInternal = Spread<\n  {\n    items: Array<SlashMenuItemInternal>\n  },\n  SlashMenuGroup\n>\n"],"mappings":"AAqDA","ignoreList":[]}

package/dist/lexical/plugins/SlashMenu/index.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import './index.scss';
+export declare function SlashMenuPlugin({ anchorElem, }: {
+    anchorElem?: HTMLElement;
+}): React.ReactElement;
+//# sourceMappingURL=index.d.ts.map

package/dist/lexical/plugins/SlashMenu/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lexical/plugins/SlashMenu/index.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAW9B,OAAO,cAAc,CAAA;AA+DrB,wBAAgB,eAAe,CAAC,EAC9B,UAA0B,GAC3B,EAAE;IACD,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,KAAK,CAAC,YAAY,CA6JrB"}

package/dist/lexical/plugins/SlashMenu/index.js

@@ -0,0 +1,199 @@
+'use client';
+
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { useTranslation } from '@ruya.sa/ui';
+import { useCallback, useMemo, useState } from 'react';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js';
+import { LexicalTypeaheadMenuPlugin } from './LexicalTypeaheadMenuPlugin/index.js';
+import { useMenuTriggerMatch } from './useMenuTriggerMatch.js';
+const baseClass = 'slash-menu-popup';
+function SlashMenuItem({
+  isSelected,
+  item,
+  onClick,
+  onMouseEnter,
+  ref
+}) {
+  const {
+    fieldProps: {
+      featureClientSchemaMap,
+      schemaPath
+    }
+  } = useEditorConfigContext();
+  const {
+    i18n
+  } = useTranslation();
+  let className = `${baseClass}__item ${baseClass}__item-${item.key}`;
+  if (isSelected) {
+    className += ` ${baseClass}__item--selected`;
+  }
+  let title = item.key;
+  if (item.label) {
+    title = typeof item.label === 'function' ? item.label({
+      featureClientSchemaMap,
+      i18n,
+      schemaPath
+    }) : item.label;
+  }
+  // Crop title to max. 25 characters
+  if (title.length > 25) {
+    title = title.substring(0, 25) + '...';
+  }
+  return /*#__PURE__*/_jsxs("button", {
+    "aria-selected": isSelected,
+    className: className,
+    id: baseClass + '__item-' + item.key,
+    onClick: onClick,
+    onMouseEnter: onMouseEnter,
+    ref: ref,
+    role: "option",
+    tabIndex: -1,
+    type: "button",
+    children: [item?.Icon && /*#__PURE__*/_jsx(item.Icon, {}), /*#__PURE__*/_jsx("span", {
+      className: `${baseClass}__item-text`,
+      children: title
+    })]
+  }, item.key);
+}
+export function SlashMenuPlugin({
+  anchorElem = document.body
+}) {
+  const [editor] = useLexicalComposerContext();
+  const [queryString, setQueryString] = useState(null);
+  const {
+    editorConfig
+  } = useEditorConfigContext();
+  const {
+    i18n
+  } = useTranslation();
+  const {
+    fieldProps: {
+      featureClientSchemaMap,
+      schemaPath
+    }
+  } = useEditorConfigContext();
+  const checkForTriggerMatch = useMenuTriggerMatch('/', {
+    minLength: 0
+  });
+  const getDynamicItems = useCallback(() => {
+    let groupWithItems = [];
+    for (const dynamicItem of editorConfig.features.slashMenu.dynamicGroups) {
+      if (queryString) {
+        const dynamicGroupWithItems = dynamicItem({
+          editor,
+          queryString
+        });
+        groupWithItems = groupWithItems.concat(dynamicGroupWithItems);
+      }
+    }
+    return groupWithItems;
+  }, [editor, queryString, editorConfig?.features]);
+  const groups = useMemo(() => {
+    let groupsWithItems = [];
+    for (const groupWithItem of editorConfig?.features.slashMenu.groups ?? []) {
+      groupsWithItems.push(groupWithItem);
+    }
+    if (queryString) {
+      // Filter current groups first
+      // @ts-expect-error - TODO: fix this
+      groupsWithItems = groupsWithItems.map(group => {
+        const filteredItems = group.items.filter(item => {
+          let itemTitle = item.key;
+          if (item.label) {
+            itemTitle = typeof item.label === 'function' ? item.label({
+              featureClientSchemaMap,
+              i18n,
+              schemaPath
+            }) : item.label;
+          }
+          if (new RegExp(queryString, 'gi').exec(itemTitle)) {
+            return true;
+          }
+          if (item.keywords != null) {
+            return item.keywords.some(keyword => new RegExp(queryString, 'gi').exec(keyword));
+          }
+          return false;
+        });
+        if (filteredItems.length) {
+          return {
+            ...group,
+            items: filteredItems
+          };
+        }
+        return null;
+      });
+      groupsWithItems = groupsWithItems.filter(group_0 => group_0 != null);
+      // Now add dynamic groups
+      const dynamicItemGroups = getDynamicItems();
+      // merge dynamic items into groups
+      for (const dynamicGroup of dynamicItemGroups) {
+        // 1. find the group with the same name or create new one
+        let group_2 = groupsWithItems.find(group_1 => group_1.key === dynamicGroup.key);
+        if (!group_2) {
+          group_2 = {
+            ...dynamicGroup,
+            items: []
+          };
+        } else {
+          groupsWithItems = groupsWithItems.filter(group_3 => group_3.key !== dynamicGroup.key);
+        }
+        // 2. Add items to group items array and add to sanitized.slashMenu.groupsWithItems
+        if (group_2?.items?.length) {
+          group_2.items = group_2.items.concat(group_2.items);
+        }
+        groupsWithItems.push(group_2);
+      }
+    }
+    return groupsWithItems;
+  }, [queryString, editorConfig?.features.slashMenu.groups, getDynamicItems, featureClientSchemaMap, i18n, schemaPath]);
+  return /*#__PURE__*/_jsx(LexicalTypeaheadMenuPlugin, {
+    anchorElem: anchorElem,
+    groups: groups,
+    menuRenderFn: (anchorElementRef, {
+      selectedItemKey,
+      selectItemAndCleanUp,
+      setSelectedItemKey
+    }) => anchorElementRef.current && groups.length ? /*#__PURE__*/ReactDOM.createPortal(/*#__PURE__*/_jsx("div", {
+      className: baseClass,
+      children: groups.map(group_4 => {
+        let groupTitle = group_4.key;
+        if (group_4.label && featureClientSchemaMap) {
+          groupTitle = typeof group_4.label === 'function' ? group_4.label({
+            featureClientSchemaMap,
+            i18n,
+            schemaPath
+          }) : group_4.label;
+        }
+        return /*#__PURE__*/_jsxs("div", {
+          className: `${baseClass}__group ${baseClass}__group-${group_4.key}`,
+          children: [/*#__PURE__*/_jsx("div", {
+            className: `${baseClass}__group-title`,
+            children: groupTitle
+          }), group_4.items.map((item_0, oi) => /*#__PURE__*/_jsx(SlashMenuItem, {
+            index: oi,
+            isSelected: selectedItemKey === item_0.key,
+            item: item_0,
+            onClick: () => {
+              setSelectedItemKey(item_0.key);
+              selectItemAndCleanUp(item_0);
+            },
+            onMouseEnter: () => {
+              setSelectedItemKey(item_0.key);
+            },
+            ref: el => {
+              item_0.ref = {
+                current: el
+              };
+            }
+          }, item_0.key))]
+        }, group_4.key);
+      })
+    }), anchorElementRef.current) : null,
+    onQueryChange: setQueryString,
+    triggerFn: checkForTriggerMatch
+  });
+}
+//# sourceMappingURL=index.js.map

package/dist/lexical/plugins/SlashMenu/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["useLexicalComposerContext","useTranslation","useCallback","useMemo","useState","React","ReactDOM","useEditorConfigContext","LexicalTypeaheadMenuPlugin","useMenuTriggerMatch","baseClass","SlashMenuItem","isSelected","item","onClick","onMouseEnter","ref","fieldProps","featureClientSchemaMap","schemaPath","i18n","className","key","title","label","length","substring","_jsxs","id","role","tabIndex","type","Icon","_jsx","SlashMenuPlugin","anchorElem","document","body","editor","queryString","setQueryString","editorConfig","checkForTriggerMatch","minLength","getDynamicItems","groupWithItems","dynamicItem","features","slashMenu","dynamicGroups","dynamicGroupWithItems","concat","groups","groupsWithItems","groupWithItem","push","map","group","filteredItems","items","filter","itemTitle","RegExp","exec","keywords","some","keyword","dynamicItemGroups","dynamicGroup","find","menuRenderFn","anchorElementRef","selectedItemKey","selectItemAndCleanUp","setSelectedItemKey","current","createPortal","groupTitle","oi","index","el","onQueryChange","triggerFn"],"sources":["../../../../src/lexical/plugins/SlashMenu/index.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { useTranslation } from '@ruya.sa/ui'\nimport { useCallback, useMemo, useState } from 'react'\nimport * as React from 'react'\nimport * as ReactDOM from 'react-dom'\n\nimport type {\n  SlashMenuGroup,\n  SlashMenuGroupInternal,\n  SlashMenuItemInternal,\n  SlashMenuItem as SlashMenuItemType,\n} from './LexicalTypeaheadMenuPlugin/types.js'\n\nimport { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js'\nimport './index.scss'\nimport { LexicalTypeaheadMenuPlugin } from './LexicalTypeaheadMenuPlugin/index.js'\nimport { useMenuTriggerMatch } from './useMenuTriggerMatch.js'\n\nconst baseClass = 'slash-menu-popup'\n\nfunction SlashMenuItem({\n  isSelected,\n  item,\n  onClick,\n  onMouseEnter,\n  ref,\n}: {\n  index: number\n  isSelected: boolean\n  item: SlashMenuItemInternal\n  onClick: () => void\n  onMouseEnter: () => void\n  ref?: React.Ref<HTMLButtonElement>\n}) {\n  const {\n    fieldProps: { featureClientSchemaMap, schemaPath },\n  } = useEditorConfigContext()\n\n  const { i18n } = useTranslation<{}, string>()\n\n  let className = `${baseClass}__item ${baseClass}__item-${item.key}`\n  if (isSelected) {\n    className += ` ${baseClass}__item--selected`\n  }\n\n  let title = item.key\n  if (item.label) {\n    title =\n      typeof item.label === 'function'\n        ? item.label({ featureClientSchemaMap, i18n, schemaPath })\n        : item.label\n  }\n  // Crop title to max. 25 characters\n  if (title.length > 25) {\n    title = title.substring(0, 25) + '...'\n  }\n\n  return (\n    <button\n      aria-selected={isSelected}\n      className={className}\n      id={baseClass + '__item-' + item.key}\n      key={item.key}\n      onClick={onClick}\n      onMouseEnter={onMouseEnter}\n      ref={ref}\n      role=\"option\"\n      tabIndex={-1}\n      type=\"button\"\n    >\n      {item?.Icon && <item.Icon />}\n\n      <span className={`${baseClass}__item-text`}>{title}</span>\n    </button>\n  )\n}\n\nexport function SlashMenuPlugin({\n  anchorElem = document.body,\n}: {\n  anchorElem?: HTMLElement\n}): React.ReactElement {\n  const [editor] = useLexicalComposerContext()\n  const [queryString, setQueryString] = useState<null | string>(null)\n  const { editorConfig } = useEditorConfigContext()\n  const { i18n } = useTranslation<{}, string>()\n  const {\n    fieldProps: { featureClientSchemaMap, schemaPath },\n  } = useEditorConfigContext()\n\n  const checkForTriggerMatch = useMenuTriggerMatch('/', {\n    minLength: 0,\n  })\n\n  const getDynamicItems = useCallback(() => {\n    let groupWithItems: Array<SlashMenuGroup> = []\n\n    for (const dynamicItem of editorConfig.features.slashMenu.dynamicGroups) {\n      if (queryString) {\n        const dynamicGroupWithItems = dynamicItem({\n          editor,\n          queryString,\n        })\n        groupWithItems = groupWithItems.concat(dynamicGroupWithItems)\n      }\n    }\n\n    return groupWithItems\n  }, [editor, queryString, editorConfig?.features])\n\n  const groups: SlashMenuGroup[] = useMemo(() => {\n    let groupsWithItems: SlashMenuGroup[] = []\n    for (const groupWithItem of editorConfig?.features.slashMenu.groups ?? []) {\n      groupsWithItems.push(groupWithItem)\n    }\n\n    if (queryString) {\n      // Filter current groups first\n      // @ts-expect-error - TODO: fix this\n      groupsWithItems = groupsWithItems.map((group) => {\n        const filteredItems = group.items.filter((item) => {\n          let itemTitle = item.key\n          if (item.label) {\n            itemTitle =\n              typeof item.label === 'function'\n                ? item.label({ featureClientSchemaMap, i18n, schemaPath })\n                : item.label\n          }\n\n          if (new RegExp(queryString, 'gi').exec(itemTitle)) {\n            return true\n          }\n          if (item.keywords != null) {\n            return item.keywords.some((keyword) => new RegExp(queryString, 'gi').exec(keyword))\n          }\n          return false\n        })\n        if (filteredItems.length) {\n          return {\n            ...group,\n            items: filteredItems,\n          }\n        }\n        return null\n      })\n\n      groupsWithItems = groupsWithItems.filter((group) => group != null)\n\n      // Now add dynamic groups\n      const dynamicItemGroups = getDynamicItems()\n\n      // merge dynamic items into groups\n      for (const dynamicGroup of dynamicItemGroups) {\n        // 1. find the group with the same name or create new one\n        let group = groupsWithItems.find((group) => group.key === dynamicGroup.key)\n        if (!group) {\n          group = {\n            ...dynamicGroup,\n            items: [],\n          }\n        } else {\n          groupsWithItems = groupsWithItems.filter((group) => group.key !== dynamicGroup.key)\n        }\n\n        // 2. Add items to group items array and add to sanitized.slashMenu.groupsWithItems\n        if (group?.items?.length) {\n          group.items = group.items.concat(group.items)\n        }\n        groupsWithItems.push(group)\n      }\n    }\n\n    return groupsWithItems\n  }, [\n    queryString,\n    editorConfig?.features.slashMenu.groups,\n    getDynamicItems,\n    featureClientSchemaMap,\n    i18n,\n    schemaPath,\n  ])\n\n  return (\n    <LexicalTypeaheadMenuPlugin\n      anchorElem={anchorElem}\n      groups={groups as SlashMenuGroupInternal[]}\n      menuRenderFn={(\n        anchorElementRef,\n        { selectedItemKey, selectItemAndCleanUp, setSelectedItemKey },\n      ) =>\n        anchorElementRef.current && groups.length\n          ? ReactDOM.createPortal(\n              <div className={baseClass}>\n                {groups.map((group) => {\n                  let groupTitle = group.key\n                  if (group.label && featureClientSchemaMap) {\n                    groupTitle =\n                      typeof group.label === 'function'\n                        ? group.label({ featureClientSchemaMap, i18n, schemaPath })\n                        : group.label\n                  }\n\n                  return (\n                    <div\n                      className={`${baseClass}__group ${baseClass}__group-${group.key}`}\n                      key={group.key}\n                    >\n                      <div className={`${baseClass}__group-title`}>{groupTitle}</div>\n                      {group.items.map((item, oi: number) => (\n                        <SlashMenuItem\n                          index={oi}\n                          isSelected={selectedItemKey === item.key}\n                          item={item as SlashMenuItemInternal}\n                          key={item.key}\n                          onClick={() => {\n                            setSelectedItemKey(item.key)\n                            selectItemAndCleanUp(item)\n                          }}\n                          onMouseEnter={() => {\n                            setSelectedItemKey(item.key)\n                          }}\n                          ref={(el) => {\n                            ;(item as SlashMenuItemInternal).ref = { current: el }\n                          }}\n                        />\n                      ))}\n                    </div>\n                  )\n                })}\n              </div>,\n              anchorElementRef.current,\n            )\n          : null\n      }\n      onQueryChange={setQueryString}\n      triggerFn={checkForTriggerMatch}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/lexical/plugins/SlashMenu/useMenuTriggerMatch.d.ts

@@ -0,0 +1,23 @@
+import type { LexicalEditor } from 'lexical';
+export type TriggerFn = ({ editor, query, }: {
+    editor: LexicalEditor;
+    /** The query string is the POTENTIAL trigger AND the text after the trigger text. */
+    query: string;
+}) => MenuTextMatch | null;
+export type MenuTextMatch = {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+};
+/**
+ * Returns a function which checks if the trigger (e.g. '/') is present in the query and, if so, returns the matching string (text after the trigger)
+ */
+export declare function useMenuTriggerMatch(
+/**
+ * Text which triggers the menu. Everything after this text will be used as the query.
+ */
+trigger: string, { maxLength, minLength }: {
+    maxLength?: number;
+    minLength?: number;
+}): TriggerFn;
+//# sourceMappingURL=useMenuTriggerMatch.d.ts.map

package/dist/lexical/plugins/SlashMenu/useMenuTriggerMatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMenuTriggerMatch.d.ts","sourceRoot":"","sources":["../../../../src/lexical/plugins/SlashMenu/useMenuTriggerMatch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM5C,MAAM,MAAM,SAAS,GAAG,CAAC,EACvB,MAAM,EACN,KAAK,GACN,EAAE;IACD,MAAM,EAAE,aAAa,CAAA;IACrB,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;CACd,KAAK,aAAa,GAAG,IAAI,CAAA;AAE1B,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED;;GAEG;AACH,wBAAgB,mBAAmB;AACjC;;GAEG;AACH,OAAO,EAAE,MAAM,EACf,EAAE,SAAc,EAAE,SAAa,EAAE,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5E,SAAS,CAqCX"}

package/dist/lexical/plugins/SlashMenu/useMenuTriggerMatch.js

@@ -0,0 +1,48 @@
+'use client';
+
+import { c as _c } from "react/compiler-runtime";
+import { useCallback } from 'react';
+import { PUNCTUATION } from './LexicalTypeaheadMenuPlugin/index.js';
+/**
+ * Returns a function which checks if the trigger (e.g. '/') is present in the query and, if so, returns the matching string (text after the trigger)
+ */
+export function useMenuTriggerMatch(trigger, t0) {
+  const $ = _c(4);
+  const {
+    maxLength: t1,
+    minLength: t2
+  } = t0;
+  const maxLength = t1 === undefined ? 75 : t1;
+  const minLength = t2 === undefined ? 1 : t2;
+  let t3;
+  if ($[0] !== maxLength || $[1] !== minLength || $[2] !== trigger) {
+    t3 = t4 => {
+      const {
+        query
+      } = t4;
+      const validChars = "[^" + trigger + PUNCTUATION + "\\s]";
+      const TypeaheadTriggerRegex = new RegExp("(^|\\s|\\()([" + trigger + "]" + "((?:" + validChars + "){0," + maxLength + "})" + ")$");
+      const match = TypeaheadTriggerRegex.exec(query);
+      if (match !== null) {
+        const maybeLeadingWhitespace = match[1];
+        const matchingString = match[3];
+        if (matchingString.length >= minLength) {
+          return {
+            leadOffset: match.index + maybeLeadingWhitespace.length,
+            matchingString,
+            replaceableString: match[2]
+          };
+        }
+      }
+      return null;
+    };
+    $[0] = maxLength;
+    $[1] = minLength;
+    $[2] = trigger;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  return t3;
+}
+//# sourceMappingURL=useMenuTriggerMatch.js.map

package/dist/lexical/plugins/SlashMenu/useMenuTriggerMatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMenuTriggerMatch.js","names":["c","_c","useCallback","PUNCTUATION","useMenuTriggerMatch","trigger","t0","$","maxLength","t1","minLength","t2","undefined","t3","t4","query","validChars","TypeaheadTriggerRegex","RegExp","match","exec","maybeLeadingWhitespace","matchingString","length","leadOffset","index","replaceableString"],"sources":["../../../../src/lexical/plugins/SlashMenu/useMenuTriggerMatch.ts"],"sourcesContent":["'use client'\nimport type { LexicalEditor } from 'lexical'\n\nimport { useCallback } from 'react'\n\nimport { PUNCTUATION } from './LexicalTypeaheadMenuPlugin/index.js'\n\nexport type TriggerFn = ({\n  editor,\n  query,\n}: {\n  editor: LexicalEditor\n  /** The query string is the POTENTIAL trigger AND the text after the trigger text. */\n  query: string\n}) => MenuTextMatch | null\n\nexport type MenuTextMatch = {\n  leadOffset: number\n  matchingString: string\n  replaceableString: string\n}\n\n/**\n * Returns a function which checks if the trigger (e.g. '/') is present in the query and, if so, returns the matching string (text after the trigger)\n */\nexport function useMenuTriggerMatch(\n  /**\n   * Text which triggers the menu. Everything after this text will be used as the query.\n   */\n  trigger: string,\n  { maxLength = 75, minLength = 1 }: { maxLength?: number; minLength?: number },\n): TriggerFn {\n  return useCallback(\n    ({ query }) => {\n      const validChars = '[^' + trigger + PUNCTUATION + '\\\\s]'\n      const TypeaheadTriggerRegex = new RegExp(\n        '(^|\\\\s|\\\\()(' +\n          '[' +\n          trigger +\n          ']' +\n          '((?:' +\n          validChars +\n          '){0,' +\n          maxLength +\n          '})' +\n          ')$',\n      )\n      const match = TypeaheadTriggerRegex.exec(query)\n      if (match !== null) {\n        const maybeLeadingWhitespace = match[1]!\n\n        /**\n         * matchingString is only the text AFTER the trigger text. (So everything after the /)\n         */\n        const matchingString = match[3]!\n\n        if (matchingString.length >= minLength) {\n          return {\n            leadOffset: match.index + maybeLeadingWhitespace.length,\n            matchingString,\n            replaceableString: match[2]!, // replaceableString is the trigger text + the matching string\n          }\n        }\n      }\n      return null\n    },\n    [maxLength, minLength, trigger],\n  )\n}\n"],"mappings":"AAAA;;AAAA,SAAAA,CAAA,IAAAC,EAAA;AAGA,SAASC,WAAW,QAAQ;AAE5B,SAASC,WAAW,QAAQ;AAiB5B;;;AAGA,OAAO,SAAAC,oBAAAC,OAAA,EAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAN,EAAA;EAKL;IAAAO,SAAA,EAAAC,EAAA;IAAAC,SAAA,EAAAC;EAAA,IAAAL,EAA6E;EAA3E,MAAAE,SAAA,GAAAC,EAAc,KAAAG,SAAA,QAAdH,EAAc;EAAE,MAAAC,SAAA,GAAAC,EAAa,KAAAC,SAAA,OAAbD,EAAa;EAAA,IAAAE,EAAA;EAAA,IAAAN,CAAA,QAAAC,SAAA,IAAAD,CAAA,QAAAG,SAAA,IAAAH,CAAA,QAAAF,OAAA;IAG7BQ,EAAA,GAAAC,EAAA;MAAC;QAAAC;MAAA,IAAAD,EAAS;MACR,MAAAE,UAAA,GAAmB,OAAOX,OAAA,GAAAF,WAAU,GAAc;MAClD,MAAAc,qBAAA,OAAAC,MAAA,CACE,eACE,GACAb,OAAA,GACA,MACA,SACAW,UAAA,GACA,SACAR,SAAA,GACA,OACA;MAEJ,MAAAW,KAAA,GAAcF,qBAAA,CAAAG,IAAA,CAA2BL,KAAA;MAAA,IACrCI,KAAA,SAAU;QACZ,MAAAE,sBAAA,GAA+BF,KAAK;QAKpC,MAAAG,cAAA,GAAuBH,KAAK;QAAG,IAE3BG,cAAA,CAAAC,MAAA,IAAyBb,SAAA;UAAA;YAAAc,UAAA,EAEbL,KAAA,CAAAM,KAAA,GAAcJ,sBAAA,CAAAE,MAA6B;YAAAD,cAAA;YAAAI,iBAAA,EAEpCP,KAAK;UAAA;QAAA;MAAA;MAAA;IAAA;IAKhCZ,CAAA,MAAAC,SAAA;IAAAD,CAAA,MAAAG,SAAA;IAAAH,CAAA,MAAAF,OAAA;IAAAE,CAAA,MAAAM,EAAA;EAAA;IAAAA,EAAA,GAAAN,CAAA;EAAA;EAAA,OAjCKM,EAkC0B;AAAA","ignoreList":[]}

package/dist/lexical/plugins/TextPlugin/index.d.ts

@@ -0,0 +1,5 @@
+import type { SanitizedClientFeatures } from '../../../features/typesClient.js';
+export declare function TextPlugin({ features }: {
+    features: SanitizedClientFeatures;
+}): null;
+//# sourceMappingURL=index.d.ts.map

package/dist/lexical/plugins/TextPlugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lexical/plugins/TextPlugin/index.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAE/E,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,uBAAuB,CAAA;CAAE,QAuB7E"}