@lexical/react 0.3.7 → 0.3.10

package/LexicalAutoEmbedPlugin.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { LexicalNode } from 'lexical';
+import { TypeaheadOption } from '@lexical/react/src/LexicalTypeaheadMenuPlugin';
+import { LexicalCommand, LexicalEditor } from 'lexical';
+import * as React from 'react';
+export declare type EmbedMatchResult = {
+    url: string;
+    id: string;
+};
+export interface EmbedConfig {
+    type: string;
+    parseUrl: (text: string) => EmbedMatchResult | null;
+    insertNode: (editor: LexicalEditor, result: EmbedMatchResult) => void;
+}
+export declare const URL_MATCHER: RegExp;
+export declare const INSERT_EMBED_COMMAND: LexicalCommand<EmbedConfig['type']>;
+export declare type EmbedMenuProps = {
+    selectedItemIndex: number | null;
+    onOptionClick: (option: AutoEmbedOption, index: number) => void;
+    onOptionMouseEnter: (index: number) => void;
+    options: Array<AutoEmbedOption>;
+};
+export declare type EmbedMenuComponent = React.ComponentType<EmbedMenuProps>;
+export declare class AutoEmbedOption extends TypeaheadOption {
+    title: string;
+    icon?: JSX.Element;
+    onSelect: (targetNode: LexicalNode | null) => void;
+    constructor(title: string, options: {
+        icon?: JSX.Element;
+        onSelect: (targetNode: LexicalNode | null) => void;
+    });
+}
+declare type LexicalAutoEmbedPluginProps<TEmbedConfig extends EmbedConfig> = {
+    embedConfigs: Array<TEmbedConfig>;
+    onOpenEmbedModalForConfig: (embedConfig: TEmbedConfig) => void;
+    menuComponent: EmbedMenuComponent;
+    getMenuOptions: (activeEmbedConfig: TEmbedConfig, embedFn: () => void, dismissFn: () => void) => Array<AutoEmbedOption>;
+};
+export declare function LexicalAutoEmbedPlugin<TEmbedConfig extends EmbedConfig>({ embedConfigs, onOpenEmbedModalForConfig, getMenuOptions, menuComponent: MenuComponent, }: LexicalAutoEmbedPluginProps<TEmbedConfig>): JSX.Element | null;
+export {};

package/LexicalAutoEmbedPlugin.dev.js

@@ -0,0 +1,490 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var link = require('@lexical/link');
+var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var utils = require('@lexical/utils');
+var lexical = require('lexical');
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const useLayoutEffectImpl = CAN_USE_DOM ? React.useLayoutEffect : React.useEffect;
+var useLayoutEffect = useLayoutEffectImpl;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+class TypeaheadOption {
+  constructor(key) {
+    this.key = key;
+    this.ref = {
+      current: null
+    };
+    this.setRefElement = this.setRefElement.bind(this);
+  }
+
+  setRefElement(element) {
+    this.ref = {
+      current: element
+    };
+  }
+
+}
+
+const scrollIntoViewIfNeeded = target => {
+  const container = document.getElementById('typeahead-menu');
+
+  if (container) {
+    const containerRect = container.getBoundingClientRect();
+    const targetRect = target.getBoundingClientRect();
+
+    if (targetRect.bottom > containerRect.bottom) {
+      target.scrollIntoView(false);
+    } else if (targetRect.top < containerRect.top) {
+      target.scrollIntoView();
+    }
+  }
+};
+/**
+ * Walk backwards along user input and forward through entity title to try
+ * and replace more of the user's text with entity.
+ */
+
+
+function getFullMatchOffset(documentText, entryText, offset) {
+  let triggerOffset = offset;
+
+  for (let i = triggerOffset; i <= entryText.length; i++) {
+    if (documentText.substr(-i) === entryText.substr(0, i)) {
+      triggerOffset = i;
+    }
+  }
+
+  return triggerOffset;
+}
+/**
+ * Split Lexical TextNode and return a new TextNode only containing matched text.
+ * Common use cases include: removing the node, replacing with a new node.
+ */
+
+
+function splitNodeContainingQuery(editor, match) {
+  const selection = lexical.$getSelection();
+
+  if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
+    return null;
+  }
+
+  const anchor = selection.anchor;
+
+  if (anchor.type !== 'text') {
+    return null;
+  }
+
+  const anchorNode = anchor.getNode();
+
+  if (!anchorNode.isSimpleText()) {
+    return null;
+  }
+
+  const selectionOffset = anchor.offset;
+  const textContent = anchorNode.getTextContent().slice(0, selectionOffset);
+  const characterOffset = match.replaceableString.length;
+  const queryOffset = getFullMatchOffset(textContent, match.matchingString, characterOffset);
+  const startOffset = selectionOffset - queryOffset;
+
+  if (startOffset < 0) {
+    return null;
+  }
+
+  let newNode;
+
+  if (startOffset === 0) {
+    [newNode] = anchorNode.splitText(selectionOffset);
+  } else {
+    [, newNode] = anchorNode.splitText(startOffset, selectionOffset);
+  }
+
+  return newNode;
+}
+
+function startTransition(callback) {
+  if (React.startTransition) {
+    React.startTransition(callback);
+  } else {
+    callback();
+  }
+}
+
+function LexicalPopoverMenu({
+  close,
+  editor,
+  anchorElement,
+  resolution,
+  options,
+  menuRenderFn,
+  onSelectOption
+}) {
+  const [selectedIndex, setHighlightedIndex] = React.useState(null);
+  React.useEffect(() => {
+    setHighlightedIndex(0);
+  }, [resolution.match.matchingString]);
+  const selectOptionAndCleanUp = React.useCallback(async selectedEntry => {
+    editor.update(() => {
+      const textNodeContainingQuery = splitNodeContainingQuery(editor, resolution.match);
+      onSelectOption(selectedEntry, textNodeContainingQuery, close, resolution.match.matchingString);
+    });
+  }, [close, editor, resolution.match, onSelectOption]);
+  const updateSelectedIndex = React.useCallback(index => {
+    const rootElem = editor.getRootElement();
+
+    if (rootElem !== null) {
+      rootElem.setAttribute('aria-activedescendant', 'typeahead-item-' + index);
+      setHighlightedIndex(index);
+    }
+  }, [editor]);
+  React.useEffect(() => {
+    return () => {
+      const rootElem = editor.getRootElement();
+
+      if (rootElem !== null) {
+        rootElem.removeAttribute('aria-activedescendant');
+      }
+    };
+  }, [editor]);
+  useLayoutEffect(() => {
+    if (options === null) {
+      setHighlightedIndex(null);
+    } else if (selectedIndex === null) {
+      updateSelectedIndex(0);
+    }
+  }, [options, selectedIndex, updateSelectedIndex]);
+  React.useEffect(() => {
+    return utils.mergeRegister(editor.registerCommand(lexical.KEY_ARROW_DOWN_COMMAND, payload => {
+      const event = payload;
+
+      if (options !== null && options.length && selectedIndex !== null) {
+        const newSelectedIndex = selectedIndex !== options.length - 1 ? selectedIndex + 1 : 0;
+        updateSelectedIndex(newSelectedIndex);
+        const option = options[newSelectedIndex];
+
+        if (option.ref != null && option.ref.current) {
+          scrollIntoViewIfNeeded(option.ref.current);
+        }
+
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+
+      return true;
+    }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ARROW_UP_COMMAND, payload => {
+      const event = payload;
+
+      if (options !== null && options.length && selectedIndex !== null) {
+        const newSelectedIndex = selectedIndex !== 0 ? selectedIndex - 1 : options.length - 1;
+        updateSelectedIndex(newSelectedIndex);
+        const option = options[newSelectedIndex];
+
+        if (option.ref != null && option.ref.current) {
+          scrollIntoViewIfNeeded(option.ref.current);
+        }
+
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+
+      return true;
+    }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ESCAPE_COMMAND, payload => {
+      const event = payload;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      close();
+      return true;
+    }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_TAB_COMMAND, payload => {
+      const event = payload;
+
+      if (options === null || selectedIndex === null || options[selectedIndex] == null) {
+        return false;
+      }
+
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      selectOptionAndCleanUp(options[selectedIndex]);
+      return true;
+    }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ENTER_COMMAND, event => {
+      if (options === null || selectedIndex === null || options[selectedIndex] == null) {
+        return false;
+      }
+
+      if (event !== null) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+
+      selectOptionAndCleanUp(options[selectedIndex]);
+      return true;
+    }, lexical.COMMAND_PRIORITY_LOW));
+  }, [selectOptionAndCleanUp, close, editor, options, selectedIndex, updateSelectedIndex]);
+  const listItemProps = React.useMemo(() => ({
+    selectOptionAndCleanUp,
+    selectedIndex,
+    setHighlightedIndex
+  }), [selectOptionAndCleanUp, selectedIndex]);
+  return menuRenderFn(anchorElement, listItemProps, resolution.match.matchingString);
+}
+
+function useAnchorElementRef(resolution, options) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const anchorElementRef = React.useRef(document.createElement('div'));
+  React.useEffect(() => {
+    const rootElement = editor.getRootElement();
+
+    function positionMenu() {
+      const containerDiv = anchorElementRef.current;
+      containerDiv.setAttribute('aria-label', 'Typeahead menu');
+      containerDiv.setAttribute('id', 'typeahead-menu');
+      containerDiv.setAttribute('role', 'listbox');
+
+      if (rootElement !== null && resolution !== null) {
+        const {
+          left,
+          top,
+          height,
+          width
+        } = resolution.getRect();
+        containerDiv.style.top = `${top + height + window.pageYOffset}px`;
+        containerDiv.style.left = `${left + width + window.pageXOffset}px`;
+        containerDiv.style.display = 'block';
+        containerDiv.style.position = 'absolute';
+
+        if (!containerDiv.isConnected) {
+          document.body.append(containerDiv);
+        }
+
+        anchorElementRef.current = containerDiv;
+        rootElement.setAttribute('aria-controls', 'typeahead-menu');
+      }
+    }
+
+    if (resolution !== null) {
+      positionMenu();
+      window.addEventListener('resize', positionMenu);
+      return () => {
+        window.removeEventListener('resize', positionMenu);
+
+        if (rootElement !== null) {
+          rootElement.removeAttribute('aria-controls');
+        }
+      };
+    }
+  }, [editor, resolution, options]);
+  return anchorElementRef;
+}
+function LexicalNodeMenuPlugin({
+  options,
+  nodeKey,
+  onClose,
+  onSelectOption,
+  menuRenderFn
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const [resolution, setResolution] = React.useState(null);
+  const anchorElementRef = useAnchorElementRef(resolution, options);
+  React.useEffect(() => {
+    if (nodeKey && resolution == null) {
+      editor.update(() => {
+        const node = lexical.$getNodeByKey(nodeKey);
+        const domElement = editor.getElementByKey(nodeKey);
+
+        if (node != null && domElement != null) {
+          const text = node.getTextContent();
+          startTransition(() => setResolution({
+            getRect: () => domElement.getBoundingClientRect(),
+            match: {
+              leadOffset: text.length,
+              matchingString: text,
+              replaceableString: text
+            }
+          }));
+        }
+      });
+    } else if (nodeKey == null && resolution != null) {
+      setResolution(null);
+    }
+  }, [editor, nodeKey, resolution]);
+  return resolution === null || editor === null ? null : /*#__PURE__*/React.createElement(LexicalPopoverMenu, {
+    close: onClose,
+    resolution: resolution,
+    editor: editor,
+    anchorElement: anchorElementRef.current,
+    options: options,
+    menuRenderFn: menuRenderFn,
+    onSelectOption: onSelectOption
+  });
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const URL_MATCHER = /((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/;
+const INSERT_EMBED_COMMAND = lexical.createCommand();
+class AutoEmbedOption extends TypeaheadOption {
+  constructor(title, options) {
+    super(title);
+    this.title = title;
+    this.icon = options.icon;
+    this.onSelect = options.onSelect.bind(this);
+  }
+
+}
+function LexicalAutoEmbedPlugin({
+  embedConfigs,
+  onOpenEmbedModalForConfig,
+  getMenuOptions,
+  menuComponent: MenuComponent
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const [nodeKey, setNodeKey] = React.useState(null);
+  const [activeEmbedConfig, setActiveEmbedConfig] = React.useState(null);
+  const reset = React.useCallback(() => {
+    setNodeKey(null);
+    setActiveEmbedConfig(null);
+  }, []);
+  const checkIfLinkNodeIsEmbeddable = React.useCallback(key => {
+    editor.getEditorState().read(() => {
+      const linkNode = lexical.$getNodeByKey(key);
+
+      if (link.$isLinkNode(linkNode)) {
+        const embedConfigMatch = embedConfigs.find(embedConfig => embedConfig.parseUrl(linkNode.__url));
+
+        if (embedConfigMatch != null) {
+          setActiveEmbedConfig(embedConfigMatch);
+          setNodeKey(linkNode.getKey());
+        }
+      }
+    });
+  }, [editor, embedConfigs]);
+  React.useEffect(() => {
+    const listener = (nodeMutations, {
+      updateTags,
+      dirtyLeaves
+    }) => {
+      for (const [key, mutation] of nodeMutations) {
+        if (mutation === 'created' && updateTags.has('paste') && dirtyLeaves.size === 1) {
+          checkIfLinkNodeIsEmbeddable(key);
+        } else if (key === nodeKey) {
+          reset();
+        }
+      }
+    };
+
+    return utils.mergeRegister(...[link.LinkNode, link.AutoLinkNode].map(Klass => editor.registerMutationListener(Klass, (...args) => listener(...args))));
+  }, [checkIfLinkNodeIsEmbeddable, editor, embedConfigs, nodeKey, reset]);
+  React.useEffect(() => {
+    return editor.registerCommand(INSERT_EMBED_COMMAND, embedConfigType => {
+      const embedConfig = embedConfigs.find(({
+        type
+      }) => type === embedConfigType);
+
+      if (embedConfig) {
+        onOpenEmbedModalForConfig(embedConfig);
+        return true;
+      }
+
+      return false;
+    }, lexical.COMMAND_PRIORITY_EDITOR);
+  }, [editor, embedConfigs, onOpenEmbedModalForConfig]);
+  const embedLinkViaActiveEmbedConfig = React.useCallback(() => {
+    if (activeEmbedConfig != null && nodeKey != null) {
+      const linkNode = editor.getEditorState().read(() => {
+        const node = lexical.$getNodeByKey(nodeKey);
+
+        if (link.$isLinkNode(node)) {
+          return node;
+        }
+
+        return null;
+      });
+
+      if (link.$isLinkNode(linkNode)) {
+        const result = activeEmbedConfig.parseUrl(linkNode.__url);
+
+        if (result != null) {
+          editor.update(() => {
+            activeEmbedConfig.insertNode(editor, result);
+          });
+
+          if (linkNode.isAttached()) {
+            editor.update(() => {
+              linkNode.remove();
+            });
+          }
+        }
+      }
+    }
+  }, [activeEmbedConfig, editor, nodeKey]);
+  const options = React.useMemo(() => {
+    return activeEmbedConfig != null && nodeKey != null ? getMenuOptions(activeEmbedConfig, embedLinkViaActiveEmbedConfig, reset) : [];
+  }, [activeEmbedConfig, embedLinkViaActiveEmbedConfig, getMenuOptions, nodeKey, reset]);
+  const onSelectOption = React.useCallback((selectedOption, targetNode, closeMenu) => {
+    editor.update(() => {
+      selectedOption.onSelect(targetNode);
+      closeMenu();
+    });
+  }, [editor]);
+  return nodeKey != null ? /*#__PURE__*/React.createElement(LexicalNodeMenuPlugin, {
+    nodeKey: nodeKey,
+    onClose: reset,
+    onSelectOption: onSelectOption,
+    options: options,
+    menuRenderFn: (anchorElement, {
+      selectedIndex,
+      selectOptionAndCleanUp,
+      setHighlightedIndex
+    }) => anchorElement && nodeKey != null ? /*#__PURE__*/ReactDOM.createPortal( /*#__PURE__*/React.createElement(MenuComponent, {
+      options: options,
+      selectedItemIndex: selectedIndex,
+      onOptionClick: (option, index) => {
+        setHighlightedIndex(index);
+        selectOptionAndCleanUp(option);
+      },
+      onOptionMouseEnter: index => {
+        setHighlightedIndex(index);
+      }
+    }), anchorElement) : null
+  }) : null;
+}
+
+exports.AutoEmbedOption = AutoEmbedOption;
+exports.INSERT_EMBED_COMMAND = INSERT_EMBED_COMMAND;
+exports.LexicalAutoEmbedPlugin = LexicalAutoEmbedPlugin;
+exports.URL_MATCHER = URL_MATCHER;

package/LexicalAutoEmbedPlugin.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const LexicalAutoEmbedPlugin = process.env.NODE_ENV === 'development' ? require('./LexicalAutoEmbedPlugin.dev.js') : require('./LexicalAutoEmbedPlugin.prod.js')
+module.exports = LexicalAutoEmbedPlugin;

package/LexicalAutoEmbedPlugin.prod.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var f=require("@lexical/link"),n=require("@lexical/react/LexicalComposerContext"),z=require("@lexical/utils"),A=require("lexical"),C=require("react"),D=require("react-dom"),E="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?C.useLayoutEffect:C.useEffect;class F{constructor(b){this.key=b;this.ref={current:null};this.setRefElement=this.setRefElement.bind(this)}setRefElement(b){this.ref={current:b}}}
+let G=b=>{var a=document.getElementById("typeahead-menu");if(a){a=a.getBoundingClientRect();const k=b.getBoundingClientRect();k.bottom>a.bottom?b.scrollIntoView(!1):k.top<a.top&&b.scrollIntoView()}};
+function H(b,a){b=A.$getSelection();if(!A.$isRangeSelection(b)||!b.isCollapsed())return null;var k=b.anchor;if("text"!==k.type)return null;b=k.getNode();if(!b.isSimpleText())return null;k=k.offset;let q=b.getTextContent().slice(0,k);var c=a.matchingString;a=a.replaceableString.length;for(let e=a;e<=c.length;e++)q.substr(-e)===c.substr(0,e)&&(a=e);a=k-a;if(0>a)return null;let g;0===a?[g]=b.splitText(k):[,g]=b.splitText(a,k);return g}function I(b){C.startTransition?C.startTransition(b):b()}
+function J({close:b,editor:a,anchorElement:k,resolution:q,options:c,menuRenderFn:g,onSelectOption:e}){let [d,v]=C.useState(null);C.useEffect(()=>{v(0)},[q.match.matchingString]);let p=C.useCallback(async h=>{a.update(()=>{const l=H(a,q.match);e(h,l,b,q.match.matchingString)})},[b,a,q.match,e]),t=C.useCallback(h=>{const l=a.getRootElement();null!==l&&(l.setAttribute("aria-activedescendant","typeahead-item-"+h),v(h))},[a]);C.useEffect(()=>()=>{let h=a.getRootElement();null!==h&&h.removeAttribute("aria-activedescendant")},
+[a]);E(()=>{null===c?v(null):null===d&&t(0)},[c,d,t]);C.useEffect(()=>z.mergeRegister(a.registerCommand(A.KEY_ARROW_DOWN_COMMAND,h=>{if(null!==c&&c.length&&null!==d){var l=d!==c.length-1?d+1:0;t(l);l=c[l];null!=l.ref&&l.ref.current&&G(l.ref.current);h.preventDefault();h.stopImmediatePropagation()}return!0},A.COMMAND_PRIORITY_LOW),a.registerCommand(A.KEY_ARROW_UP_COMMAND,h=>{if(null!==c&&c.length&&null!==d){var l=0!==d?d-1:c.length-1;t(l);l=c[l];null!=l.ref&&l.ref.current&&G(l.ref.current);h.preventDefault();
+h.stopImmediatePropagation()}return!0},A.COMMAND_PRIORITY_LOW),a.registerCommand(A.KEY_ESCAPE_COMMAND,h=>{h.preventDefault();h.stopImmediatePropagation();b();return!0},A.COMMAND_PRIORITY_LOW),a.registerCommand(A.KEY_TAB_COMMAND,h=>{if(null===c||null===d||null==c[d])return!1;h.preventDefault();h.stopImmediatePropagation();p(c[d]);return!0},A.COMMAND_PRIORITY_LOW),a.registerCommand(A.KEY_ENTER_COMMAND,h=>{if(null===c||null===d||null==c[d])return!1;null!==h&&(h.preventDefault(),h.stopImmediatePropagation());
+p(c[d]);return!0},A.COMMAND_PRIORITY_LOW)),[p,b,a,c,d,t]);let w=C.useMemo(()=>({selectOptionAndCleanUp:p,selectedIndex:d,setHighlightedIndex:v}),[p,d]);return g(k,w,q.match.matchingString)}
+function K(b,a){let [k]=n.useLexicalComposerContext(),q=C.useRef(document.createElement("div"));C.useEffect(()=>{function c(){let e=q.current;e.setAttribute("aria-label","Typeahead menu");e.setAttribute("id","typeahead-menu");e.setAttribute("role","listbox");if(null!==g&&null!==b){let {left:d,top:v,height:p,width:t}=b.getRect();e.style.top=`${v+p+window.pageYOffset}px`;e.style.left=`${d+t+window.pageXOffset}px`;e.style.display="block";e.style.position="absolute";e.isConnected||document.body.append(e);
+q.current=e;g.setAttribute("aria-controls","typeahead-menu")}}let g=k.getRootElement();if(null!==b)return c(),window.addEventListener("resize",c),()=>{window.removeEventListener("resize",c);null!==g&&g.removeAttribute("aria-controls")}},[k,b,a]);return q}
+function L({options:b,nodeKey:a,onClose:k,onSelectOption:q,menuRenderFn:c}){let [g]=n.useLexicalComposerContext(),[e,d]=C.useState(null),v=K(e,b);C.useEffect(()=>{a&&null==e?g.update(()=>{let p=A.$getNodeByKey(a),t=g.getElementByKey(a);if(null!=p&&null!=t){let w=p.getTextContent();I(()=>d({getRect:()=>t.getBoundingClientRect(),match:{leadOffset:w.length,matchingString:w,replaceableString:w}}))}}):null==a&&null!=e&&d(null)},[g,a,e]);return null===e||null===g?null:C.createElement(J,{close:k,resolution:e,
+editor:g,anchorElement:v.current,options:b,menuRenderFn:c,onSelectOption:q})}let M=A.createCommand();class N extends F{constructor(b,a){super(b);this.title=b;this.icon=a.icon;this.onSelect=a.onSelect.bind(this)}}exports.AutoEmbedOption=N;exports.INSERT_EMBED_COMMAND=M;
+exports.LexicalAutoEmbedPlugin=function({embedConfigs:b,onOpenEmbedModalForConfig:a,getMenuOptions:k,menuComponent:q}){let [c]=n.useLexicalComposerContext(),[g,e]=C.useState(null),[d,v]=C.useState(null),p=C.useCallback(()=>{e(null);v(null)},[]),t=C.useCallback(r=>{c.getEditorState().read(()=>{const m=A.$getNodeByKey(r);if(f.$isLinkNode(m)){const u=b.find(x=>x.parseUrl(m.__url));null!=u&&(v(u),e(m.getKey()))}})},[c,b]);C.useEffect(()=>{let r=(m,{updateTags:u,dirtyLeaves:x})=>{for(const [y,B]of m)"created"===
+B&&u.has("paste")&&1===x.size?t(y):y===g&&p()};return z.mergeRegister(...[f.LinkNode,f.AutoLinkNode].map(m=>c.registerMutationListener(m,(...u)=>r(...u))))},[t,c,b,g,p]);C.useEffect(()=>c.registerCommand(M,r=>{let m=b.find(({type:u})=>u===r);return m?(a(m),!0):!1},A.COMMAND_PRIORITY_EDITOR),[c,b,a]);let w=C.useCallback(()=>{if(null!=d&&null!=g){const r=c.getEditorState().read(()=>{const m=A.$getNodeByKey(g);return f.$isLinkNode(m)?m:null});if(f.$isLinkNode(r)){const m=d.parseUrl(r.__url);null!=m&&
+(c.update(()=>{d.insertNode(c,m)}),r.isAttached()&&c.update(()=>{r.remove()}))}}},[d,c,g]),h=C.useMemo(()=>null!=d&&null!=g?k(d,w,p):[],[d,w,k,g,p]),l=C.useCallback((r,m,u)=>{c.update(()=>{r.onSelect(m);u()})},[c]);return null!=g?C.createElement(L,{nodeKey:g,onClose:p,onSelectOption:l,options:h,menuRenderFn:(r,{selectedIndex:m,selectOptionAndCleanUp:u,setHighlightedIndex:x})=>r&&null!=g?D.createPortal(C.createElement(q,{options:h,selectedItemIndex:m,onOptionClick:(y,B)=>{x(B);u(y)},onOptionMouseEnter:y=>
+{x(y)}}),r):null}):null};exports.URL_MATCHER=/((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/

package/LexicalAutoLinkPlugin.dev.js

@@ -183,7 +183,7 @@ function useAutoLink(editor, matchers, onChange) {
   react.useEffect(() => {
     if (!editor.hasNodes([link.AutoLinkNode])) {
       {
-        throw Error(`LexicalAutoLinkPlugin: AutoLinkNode, TableCellNode or TableRowNode not registered on editor`);
+        throw Error(`LexicalAutoLinkPlugin: AutoLinkNode not registered on editor`);
       }
     }
 

package/LexicalAutoLinkPlugin.prod.js

@@ -7,6 +7,6 @@
 'use strict';var h=require("@lexical/link"),l=require("@lexical/react/LexicalComposerContext"),p=require("@lexical/utils"),v=require("lexical"),w=require("react");function x(a,c){for(let b=0;b<c.length;b++){let e=c[b](a);if(e)return e}return null}function y(a){a=a.getPreviousSibling();v.$isElementNode(a)&&(a=a.getLastDescendant());return null===a||v.$isLineBreakNode(a)||v.$isTextNode(a)&&a.getTextContent().endsWith(" ")}
 function A(a){a=a.getNextSibling();v.$isElementNode(a)&&(a=a.getFirstDescendant());return null===a||v.$isLineBreakNode(a)||v.$isTextNode(a)&&a.getTextContent().startsWith(" ")}
 function B(a,c,b){var e=a.getChildren();let d=e.length;for(let f=0;f<d;f++){let g=e[f];if(!v.$isTextNode(g)||!g.isSimpleText()){C(a);b(null,a.getURL());return}}e=a.getTextContent();c=x(e,c);null===c||c.text!==e?(C(a),b(null,a.getURL())):y(a)&&A(a)?(e=a.getURL(),null!==c&&e!==c.url&&(a.setURL(c.url),b(c.url,e))):(C(a),b(null,a.getURL()))}function C(a){let c=a.getChildren();var b=c.length;for(--b;0<=b;b--)a.insertAfter(c[b]);a.remove();return c.map(e=>e.getLatest())}
-function D(a,c,b){w.useEffect(()=>{if(!a.hasNodes([h.AutoLinkNode]))throw Error("Minified Lexical error #7; visit https://lexical.dev/docs/error?code=7 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");let e=(d,f)=>{b&&b(d,f)};return p.mergeRegister(a.registerNodeTransform(v.TextNode,d=>{var f=d.getParentOrThrow();if(h.$isAutoLinkNode(f))B(f,c,e);else if(!h.$isLinkNode(f)){if(d.isSimpleText()){f=d.getTextContent();let E=f.length,u=f,z=
-0,t=d;for(var g;(g=x(u,c))&&null!==g;){var m=g.index,n=z+m;let q=g.length;var r=void 0;r=0<n?" "===f[n-1]:y(d);n=n+q<E?" "===f[n+q]:A(d);if(r&&n){var k=void 0;0===m?[k,t]=t.splitText(q):[,k,t]=t.splitText(m,m+q);r=h.$createAutoLinkNode(g.url);r.append(v.$createTextNode(g.text));k.replace(r);b&&b(g.url,null)}m+=q;u=u.substring(m);z+=m}}k=d.getPreviousSibling();g=d.getNextSibling();d=d.getTextContent();h.$isAutoLinkNode(k)&&!d.startsWith(" ")&&(C(k),k=k.getURL(),b&&b(null,k));h.$isAutoLinkNode(g)&&
+function D(a,c,b){w.useEffect(()=>{if(!a.hasNodes([h.AutoLinkNode]))throw Error("Minified Lexical error #77; visit https://lexical.dev/docs/error?code=77 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");let e=(d,f)=>{b&&b(d,f)};return p.mergeRegister(a.registerNodeTransform(v.TextNode,d=>{var f=d.getParentOrThrow();if(h.$isAutoLinkNode(f))B(f,c,e);else if(!h.$isLinkNode(f)){if(d.isSimpleText()){f=d.getTextContent();let E=f.length,u=f,
+z=0,t=d;for(var g;(g=x(u,c))&&null!==g;){var m=g.index,n=z+m;let q=g.length;var r=void 0;r=0<n?" "===f[n-1]:y(d);n=n+q<E?" "===f[n+q]:A(d);if(r&&n){var k=void 0;0===m?[k,t]=t.splitText(q):[,k,t]=t.splitText(m,m+q);r=h.$createAutoLinkNode(g.url);r.append(v.$createTextNode(g.text));k.replace(r);b&&b(g.url,null)}m+=q;u=u.substring(m);z+=m}}k=d.getPreviousSibling();g=d.getNextSibling();d=d.getTextContent();h.$isAutoLinkNode(k)&&!d.startsWith(" ")&&(C(k),k=k.getURL(),b&&b(null,k));h.$isAutoLinkNode(g)&&
 !d.endsWith(" ")&&(C(g),d=g.getURL(),b&&b(null,d))}}),a.registerNodeTransform(h.AutoLinkNode,d=>{B(d,c,e)}))},[a,c,b])}exports.AutoLinkPlugin=function({matchers:a,onChange:c}){let [b]=l.useLexicalComposerContext();D(b,a,c);return null}

package/LexicalCollaborationContext.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/// <reference types="react" />
+import type { Doc } from 'yjs';
+declare type CollaborationContextType = {
+    clientID: number;
+    color: string;
+    isCollabActive: boolean;
+    name: string;
+    yjsDocMap: Map<string, Doc>;
+};
+export declare const CollaborationContext: import("react").Context<CollaborationContextType>;
+export declare function useCollaborationContext(username?: string): CollaborationContextType;
+export {};

package/LexicalCollaborationContext.dev.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var react = require('react');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const entries = [['Cat', '255,165,0'], ['Dog', '0,200,55'], ['Rabbit', '160,0,200'], ['Frog', '0,172,200'], ['Fox', '197,200,0'], ['Hedgehog', '31,200,0'], ['Pigeon', '200,0,0'], ['Squirrel', '200,0,148'], ['Bear', '255,235,0'], ['Tiger', '86,255,0'], ['Leopard', '0,255,208'], ['Zebra', '0,243,255'], ['Wolf', '0,102,255'], ['Owl', '147,0,255'], ['Gull', '255,0,153'], ['Squid', '0,220,255']];
+const randomEntry = entries[Math.floor(Math.random() * entries.length)];
+const CollaborationContext = /*#__PURE__*/react.createContext({
+  clientID: 0,
+  color: randomEntry[1],
+  isCollabActive: false,
+  name: randomEntry[0],
+  yjsDocMap: new Map()
+});
+function useCollaborationContext(username) {
+  const collabContext = react.useContext(CollaborationContext);
+
+  if (username != null) {
+    collabContext.name = username;
+  }
+
+  return collabContext;
+}
+
+exports.CollaborationContext = CollaborationContext;
+exports.useCollaborationContext = useCollaborationContext;

package/LexicalCollaborationContext.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const LexicalCollaborationContext = process.env.NODE_ENV === 'development' ? require('./LexicalCollaborationContext.dev.js') : require('./LexicalCollaborationContext.prod.js')
+module.exports = LexicalCollaborationContext;