@depup/lexical__react 0.41.0-depup.0 → 0.43.0-depup.0

package/package.json

@@ -14,26 +14,26 @@
     "rich-text"
   ],
   "license": "MIT",
-  "version": "0.41.0-depup.0",
+  "version": "0.43.0-depup.0",
   "dependencies": {
     "@floating-ui/react": "^0.27.19",
-    "@lexical/devtools-core": "0.41.0",
-    "@lexical/dragon": "0.41.0",
-    "@lexical/extension": "0.41.0",
-    "@lexical/hashtag": "0.41.0",
-    "@lexical/history": "0.41.0",
-    "@lexical/link": "0.41.0",
-    "@lexical/list": "0.41.0",
-    "@lexical/mark": "0.41.0",
-    "@lexical/markdown": "0.41.0",
-    "@lexical/overflow": "0.41.0",
-    "@lexical/plain-text": "0.41.0",
-    "@lexical/rich-text": "0.41.0",
-    "@lexical/table": "0.41.0",
-    "@lexical/text": "0.41.0",
-    "@lexical/utils": "0.41.0",
-    "@lexical/yjs": "0.41.0",
-    "lexical": "0.41.0",
+    "@lexical/devtools-core": "0.43.0",
+    "@lexical/dragon": "0.43.0",
+    "@lexical/extension": "0.43.0",
+    "@lexical/hashtag": "0.43.0",
+    "@lexical/history": "0.43.0",
+    "@lexical/link": "0.43.0",
+    "@lexical/list": "0.43.0",
+    "@lexical/mark": "0.43.0",
+    "@lexical/markdown": "0.43.0",
+    "@lexical/overflow": "0.43.0",
+    "@lexical/plain-text": "0.43.0",
+    "@lexical/rich-text": "0.43.0",
+    "@lexical/table": "0.43.0",
+    "@lexical/text": "0.43.0",
+    "@lexical/utils": "0.43.0",
+    "@lexical/yjs": "0.43.0",
+    "lexical": "0.43.0",
     "react-error-boundary": "^6.1.1"
   },
   "peerDependencies": {
@@ -466,36 +466,6 @@
         "default": "./LexicalContentEditable.js"
       }
     },
-    "./LexicalContextMenuPlugin": {
-      "import": {
-        "types": "./LexicalContextMenuPlugin.d.ts",
-        "development": "./LexicalContextMenuPlugin.dev.mjs",
-        "production": "./LexicalContextMenuPlugin.prod.mjs",
-        "node": "./LexicalContextMenuPlugin.node.mjs",
-        "default": "./LexicalContextMenuPlugin.mjs"
-      },
-      "require": {
-        "types": "./LexicalContextMenuPlugin.d.ts",
-        "development": "./LexicalContextMenuPlugin.dev.js",
-        "production": "./LexicalContextMenuPlugin.prod.js",
-        "default": "./LexicalContextMenuPlugin.js"
-      }
-    },
-    "./LexicalContextMenuPlugin.js": {
-      "import": {
-        "types": "./LexicalContextMenuPlugin.d.ts",
-        "development": "./LexicalContextMenuPlugin.dev.mjs",
-        "production": "./LexicalContextMenuPlugin.prod.mjs",
-        "node": "./LexicalContextMenuPlugin.node.mjs",
-        "default": "./LexicalContextMenuPlugin.mjs"
-      },
-      "require": {
-        "types": "./LexicalContextMenuPlugin.d.ts",
-        "development": "./LexicalContextMenuPlugin.dev.js",
-        "production": "./LexicalContextMenuPlugin.prod.js",
-        "default": "./LexicalContextMenuPlugin.js"
-      }
-    },
     "./LexicalDecoratorBlockNode": {
       "import": {
         "types": "./LexicalDecoratorBlockNode.d.ts",
@@ -646,6 +616,36 @@
         "default": "./LexicalExtensionComposer.js"
       }
     },
+    "./LexicalExtensionEditorComposer": {
+      "import": {
+        "types": "./LexicalExtensionEditorComposer.d.ts",
+        "development": "./LexicalExtensionEditorComposer.dev.mjs",
+        "production": "./LexicalExtensionEditorComposer.prod.mjs",
+        "node": "./LexicalExtensionEditorComposer.node.mjs",
+        "default": "./LexicalExtensionEditorComposer.mjs"
+      },
+      "require": {
+        "types": "./LexicalExtensionEditorComposer.d.ts",
+        "development": "./LexicalExtensionEditorComposer.dev.js",
+        "production": "./LexicalExtensionEditorComposer.prod.js",
+        "default": "./LexicalExtensionEditorComposer.js"
+      }
+    },
+    "./LexicalExtensionEditorComposer.js": {
+      "import": {
+        "types": "./LexicalExtensionEditorComposer.d.ts",
+        "development": "./LexicalExtensionEditorComposer.dev.mjs",
+        "production": "./LexicalExtensionEditorComposer.prod.mjs",
+        "node": "./LexicalExtensionEditorComposer.node.mjs",
+        "default": "./LexicalExtensionEditorComposer.mjs"
+      },
+      "require": {
+        "types": "./LexicalExtensionEditorComposer.d.ts",
+        "development": "./LexicalExtensionEditorComposer.dev.js",
+        "production": "./LexicalExtensionEditorComposer.prod.js",
+        "default": "./LexicalExtensionEditorComposer.js"
+      }
+    },
     "./LexicalHashtagPlugin": {
       "import": {
         "types": "./LexicalHashtagPlugin.d.ts",
@@ -1396,6 +1396,36 @@
         "default": "./useLexicalExtensionComponent.js"
       }
     },
+    "./useExtensionSignalValue": {
+      "import": {
+        "types": "./useExtensionSignalValue.d.ts",
+        "development": "./useLexicalExtensionSignalValue.dev.mjs",
+        "production": "./useLexicalExtensionSignalValue.prod.mjs",
+        "node": "./useLexicalExtensionSignalValue.node.mjs",
+        "default": "./useLexicalExtensionSignalValue.mjs"
+      },
+      "require": {
+        "types": "./useExtensionSignalValue.d.ts",
+        "development": "./useLexicalExtensionSignalValue.dev.js",
+        "production": "./useLexicalExtensionSignalValue.prod.js",
+        "default": "./useLexicalExtensionSignalValue.js"
+      }
+    },
+    "./useExtensionSignalValue.js": {
+      "import": {
+        "types": "./useExtensionSignalValue.d.ts",
+        "development": "./useLexicalExtensionSignalValue.dev.mjs",
+        "production": "./useLexicalExtensionSignalValue.prod.mjs",
+        "node": "./useLexicalExtensionSignalValue.node.mjs",
+        "default": "./useLexicalExtensionSignalValue.mjs"
+      },
+      "require": {
+        "types": "./useExtensionSignalValue.d.ts",
+        "development": "./useLexicalExtensionSignalValue.dev.js",
+        "production": "./useLexicalExtensionSignalValue.prod.js",
+        "default": "./useLexicalExtensionSignalValue.js"
+      }
+    },
     "./useLexicalEditable": {
       "import": {
         "types": "./useLexicalEditable.d.ts",
@@ -1565,8 +1595,8 @@
     },
     "depsUpdated": 2,
     "originalPackage": "@lexical/react",
-    "originalVersion": "0.41.0",
-    "processedAt": "2026-03-18T22:41:06.222Z",
+    "originalVersion": "0.43.0",
+    "processedAt": "2026-04-09T20:22:39.300Z",
     "smokeTest": "failed"
   }
 }

package/shared/LexicalMenu.d.ts

@@ -17,10 +17,11 @@ export type MenuResolution = {
     match?: MenuTextMatch;
     getRect: () => DOMRect;
 };
-export declare const PUNCTUATION = "\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'\"~=<>_:;";
 export declare class MenuOption {
     key: string;
     ref?: RefObject<HTMLElement | null>;
+    icon?: JSX.Element;
+    title?: JSX.Element | string;
     constructor(key: string);
     setRefElement(element: HTMLElement | null): void;
 }
@@ -29,21 +30,21 @@ export type MenuRenderFn<TOption extends MenuOption> = (anchorElementRef: RefObj
     selectOptionAndCleanUp: (option: TOption) => void;
     setHighlightedIndex: (index: number) => void;
     options: Array<TOption>;
-}, matchingString: string | null) => ReactPortal | JSX.Element | null;
+}, matchingString: string) => ReactPortal | JSX.Element | null;
 export declare function getScrollParent(element: HTMLElement, includeHidden: boolean): HTMLElement | HTMLBodyElement;
 export declare function useDynamicPositioning(resolution: MenuResolution | null, targetElement: HTMLElement | null, onReposition: () => void, onVisibilityChange?: (isInView: boolean) => void): void;
 export declare const SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND: LexicalCommand<{
     index: number;
     option: MenuOption;
 }>;
-export declare function LexicalMenu<TOption extends MenuOption>({ close, editor, anchorElementRef, resolution, options, menuRenderFn, onSelectOption, shouldSplitNodeWithQuery, commandPriority, preselectFirstItem, }: {
+export declare function LexicalMenu<TOption extends MenuOption>({ close, editor, anchorElementRef, resolution, options, menuRenderFn: menuRenderFnProp, onSelectOption, shouldSplitNodeWithQuery, commandPriority, preselectFirstItem, }: {
     close: () => void;
     editor: LexicalEditor;
     anchorElementRef: RefObject<HTMLElement | null>;
     resolution: MenuResolution;
     options: Array<TOption>;
     shouldSplitNodeWithQuery?: boolean;
-    menuRenderFn: MenuRenderFn<TOption>;
+    menuRenderFn?: MenuRenderFn<TOption>;
     onSelectOption: (option: TOption, textNodeContainingQuery: TextNode | null, closeMenu: () => void, matchingString: string) => void;
     commandPriority?: CommandListenerPriority;
     preselectFirstItem?: boolean;

package/useExtensionComponent.d.ts

@@ -1,5 +1,7 @@
 import { type AnyLexicalExtension, type LexicalExtensionDependency, type OutputComponentExtension } from 'lexical';
 export declare function useExtensionDependency<Extension extends AnyLexicalExtension>(extension: Extension): LexicalExtensionDependency<Extension>;
+export declare function useOptionalExtensionDependency<Extension extends AnyLexicalExtension>(extension: Extension): undefined | LexicalExtensionDependency<Extension>;
+export declare function usePeerExtensionDependency<Extension extends AnyLexicalExtension>(extensionName: Extension['name']): undefined | LexicalExtensionDependency<Extension>;
 /**
  * Use a Component from the given Extension that uses the ReactExtension convention
  * of exposing a Component property in its output.

package/useExtensionSignalValue.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { ReadonlySignal } from '@lexical/extension';
+import type { AnyLexicalExtension, LexicalExtensionOutput } from 'lexical';
+/**
+ * A React hook that subscribes to a signal and returns its current value.
+ * The component will re-render whenever the signal's value changes.
+ *
+ * @param s - The ReadonlySignal to subscribe to
+ * @returns The current value of the signal
+ *
+ * @example
+ * ```tsx
+ * const signal = new Signal(0);
+ * function MyComponent() {
+ *   const value = useSignalValue(signal);
+ *   return <div>Value: {value}</div>;
+ * }
+ * ```
+ */
+export declare function useSignalValue<V>(s: ReadonlySignal<V>): V;
+/**
+ * Type helper that extracts the value type from a ReadonlySignal.
+ * If the type is not a ReadonlySignal, it returns never.
+ *
+ * @example
+ * ```tsx
+ * type MySignal = ReadonlySignal<number>;
+ * type Value = SignalValue<MySignal>; // number
+ * ```
+ */
+export type SignalValue<S> = S extends ReadonlySignal<infer V> ? V : never;
+/**
+ * A React hook that subscribes to a signal property from a Lexical extension's output
+ * and returns its current value. The component will re-render whenever the signal's value changes.
+ *
+ * This hook combines the functionality of useExtensionDependency and useSignalValue,
+ * providing a convenient way to access reactive values from Lexical extensions.
+ *
+ * @param extension - The Lexical extension instance
+ * @param prop - The property name in the extension's output that contains a signal
+ * @returns The current value of the signal property
+ *
+ * @example
+ * ```tsx
+ * import {useExtensionSignalValue} from '@lexical/react/useExtensionSignalValue';
+ * import {MyExtension} from './MyExtension';
+ *
+ * function MyComponent() {
+ *   // Assuming MyExtension has a signal property 'count' in its output
+ *   const count = useExtensionSignalValue(MyExtension, 'count');
+ *   return <div>Count: {count}</div>;
+ * }
+ * ```
+ */
+export declare function useExtensionSignalValue<Extension extends AnyLexicalExtension, K extends keyof LexicalExtensionOutput<Extension>>(extension: Extension, prop: K): SignalValue<LexicalExtensionOutput<Extension>[K]>;

package/useLexicalExtensionComponent.dev.js

@@ -21,6 +21,12 @@ var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
 function useExtensionDependency(extension$1) {
   return extension.getExtensionDependencyFromEditor(LexicalComposerContext.useLexicalComposerContext()[0], extension$1);
 }
+function useOptionalExtensionDependency(extension) {
+  return usePeerExtensionDependency(extension.name);
+}
+function usePeerExtensionDependency(extensionName) {
+  return extension.getPeerDependencyFromEditor(LexicalComposerContext.useLexicalComposerContext()[0], extensionName);
+}
 
 /**
  * Use a Component from the given Extension that uses the ReactExtension convention
@@ -35,3 +41,5 @@ function useExtensionComponent(extension) {
 
 exports.useExtensionComponent = useExtensionComponent;
 exports.useExtensionDependency = useExtensionDependency;
+exports.useOptionalExtensionDependency = useOptionalExtensionDependency;
+exports.usePeerExtensionDependency = usePeerExtensionDependency;

package/useLexicalExtensionComponent.dev.mjs

@@ -6,7 +6,7 @@
  *
  */
 
-import { getExtensionDependencyFromEditor } from '@lexical/extension';
+import { getExtensionDependencyFromEditor, getPeerDependencyFromEditor } from '@lexical/extension';
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
 
 /**
@@ -19,6 +19,12 @@ import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext
 function useExtensionDependency(extension) {
   return getExtensionDependencyFromEditor(useLexicalComposerContext()[0], extension);
 }
+function useOptionalExtensionDependency(extension) {
+  return usePeerExtensionDependency(extension.name);
+}
+function usePeerExtensionDependency(extensionName) {
+  return getPeerDependencyFromEditor(useLexicalComposerContext()[0], extensionName);
+}
 
 /**
  * Use a Component from the given Extension that uses the ReactExtension convention
@@ -31,4 +37,4 @@ function useExtensionComponent(extension) {
   return useExtensionDependency(extension).output.Component;
 }
 
-export { useExtensionComponent, useExtensionDependency };
+export { useExtensionComponent, useExtensionDependency, useOptionalExtensionDependency, usePeerExtensionDependency };

package/useLexicalExtensionComponent.mjs

@@ -10,4 +10,6 @@ import * as modDev from './useLexicalExtensionComponent.dev.mjs';
 import * as modProd from './useLexicalExtensionComponent.prod.mjs';
 const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
 export const useExtensionComponent = mod.useExtensionComponent;
-export const useExtensionDependency = mod.useExtensionDependency;
+export const useExtensionDependency = mod.useExtensionDependency;
+export const useOptionalExtensionDependency = mod.useOptionalExtensionDependency;
+export const usePeerExtensionDependency = mod.usePeerExtensionDependency;

package/useLexicalExtensionComponent.node.mjs

@@ -8,4 +8,6 @@
 
 const mod = await (process.env.NODE_ENV !== 'production' ? import('./useLexicalExtensionComponent.dev.mjs') : import('./useLexicalExtensionComponent.prod.mjs'));
 export const useExtensionComponent = mod.useExtensionComponent;
-export const useExtensionDependency = mod.useExtensionDependency;
+export const useExtensionDependency = mod.useExtensionDependency;
+export const useOptionalExtensionDependency = mod.useOptionalExtensionDependency;
+export const usePeerExtensionDependency = mod.usePeerExtensionDependency;

package/useLexicalExtensionComponent.prod.js

@@ -6,4 +6,4 @@
  *
  */
 
-"use strict";var e=require("@lexical/extension"),n=require("@lexical/react/LexicalComposerContext");function t(t){return e.getExtensionDependencyFromEditor(n.useLexicalComposerContext()[0],t)}exports.useExtensionComponent=function(e){return t(e).output.Component},exports.useExtensionDependency=t;
+"use strict";var e=require("@lexical/extension"),n=require("@lexical/react/LexicalComposerContext");function t(t){return e.getExtensionDependencyFromEditor(n.useLexicalComposerContext()[0],t)}function o(t){return e.getPeerDependencyFromEditor(n.useLexicalComposerContext()[0],t)}exports.useExtensionComponent=function(e){return t(e).output.Component},exports.useExtensionDependency=t,exports.useOptionalExtensionDependency=function(e){return o(e.name)},exports.usePeerExtensionDependency=o;

package/useLexicalExtensionComponent.prod.mjs

@@ -6,4 +6,4 @@
  *
  */
 
-import{getExtensionDependencyFromEditor as o}from"@lexical/extension";import{useLexicalComposerContext as t}from"@lexical/react/LexicalComposerContext";function e(e){return o(t()[0],e)}function n(o){return e(o).output.Component}export{n as useExtensionComponent,e as useExtensionDependency};
+import{getExtensionDependencyFromEditor as n,getPeerDependencyFromEditor as t}from"@lexical/extension";import{useLexicalComposerContext as o}from"@lexical/react/LexicalComposerContext";function e(t){return n(o()[0],t)}function r(n){return i(n.name)}function i(n){return t(o()[0],n)}function u(n){return e(n).output.Component}export{u as useExtensionComponent,e as useExtensionDependency,r as useOptionalExtensionDependency,i as usePeerExtensionDependency};

package/useLexicalExtensionSignalValue.dev.js

@@ -0,0 +1,84 @@
+/**
+ * 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 useExtensionComponent = require('@lexical/react/useExtensionComponent');
+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.
+ *
+ */
+
+
+/**
+ * A React hook that subscribes to a signal and returns its current value.
+ * The component will re-render whenever the signal's value changes.
+ *
+ * @param s - The ReadonlySignal to subscribe to
+ * @returns The current value of the signal
+ *
+ * @example
+ * ```tsx
+ * const signal = new Signal(0);
+ * function MyComponent() {
+ *   const value = useSignalValue(signal);
+ *   return <div>Value: {value}</div>;
+ * }
+ * ```
+ */
+function useSignalValue(s) {
+  const [subscribe, getSnapshot] = react.useMemo(() => [s.subscribe.bind(s), s.peek.bind(s)], [s]);
+  return react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+/**
+ * Type helper that extracts the value type from a ReadonlySignal.
+ * If the type is not a ReadonlySignal, it returns never.
+ *
+ * @example
+ * ```tsx
+ * type MySignal = ReadonlySignal<number>;
+ * type Value = SignalValue<MySignal>; // number
+ * ```
+ */
+
+/**
+ * A React hook that subscribes to a signal property from a Lexical extension's output
+ * and returns its current value. The component will re-render whenever the signal's value changes.
+ *
+ * This hook combines the functionality of useExtensionDependency and useSignalValue,
+ * providing a convenient way to access reactive values from Lexical extensions.
+ *
+ * @param extension - The Lexical extension instance
+ * @param prop - The property name in the extension's output that contains a signal
+ * @returns The current value of the signal property
+ *
+ * @example
+ * ```tsx
+ * import {useExtensionSignalValue} from '@lexical/react/useExtensionSignalValue';
+ * import {MyExtension} from './MyExtension';
+ *
+ * function MyComponent() {
+ *   // Assuming MyExtension has a signal property 'count' in its output
+ *   const count = useExtensionSignalValue(MyExtension, 'count');
+ *   return <div>Count: {count}</div>;
+ * }
+ * ```
+ */
+function useExtensionSignalValue(extension, prop) {
+  const signal = useExtensionComponent.useExtensionDependency(extension).output[prop];
+  return useSignalValue(signal);
+}
+
+exports.useExtensionSignalValue = useExtensionSignalValue;
+exports.useSignalValue = useSignalValue;

package/useLexicalExtensionSignalValue.dev.mjs

@@ -0,0 +1,81 @@
+/**
+ * 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 { useExtensionDependency } from '@lexical/react/useExtensionComponent';
+import { useMemo, useSyncExternalStore } from '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.
+ *
+ */
+
+
+/**
+ * A React hook that subscribes to a signal and returns its current value.
+ * The component will re-render whenever the signal's value changes.
+ *
+ * @param s - The ReadonlySignal to subscribe to
+ * @returns The current value of the signal
+ *
+ * @example
+ * ```tsx
+ * const signal = new Signal(0);
+ * function MyComponent() {
+ *   const value = useSignalValue(signal);
+ *   return <div>Value: {value}</div>;
+ * }
+ * ```
+ */
+function useSignalValue(s) {
+  const [subscribe, getSnapshot] = useMemo(() => [s.subscribe.bind(s), s.peek.bind(s)], [s]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+/**
+ * Type helper that extracts the value type from a ReadonlySignal.
+ * If the type is not a ReadonlySignal, it returns never.
+ *
+ * @example
+ * ```tsx
+ * type MySignal = ReadonlySignal<number>;
+ * type Value = SignalValue<MySignal>; // number
+ * ```
+ */
+
+/**
+ * A React hook that subscribes to a signal property from a Lexical extension's output
+ * and returns its current value. The component will re-render whenever the signal's value changes.
+ *
+ * This hook combines the functionality of useExtensionDependency and useSignalValue,
+ * providing a convenient way to access reactive values from Lexical extensions.
+ *
+ * @param extension - The Lexical extension instance
+ * @param prop - The property name in the extension's output that contains a signal
+ * @returns The current value of the signal property
+ *
+ * @example
+ * ```tsx
+ * import {useExtensionSignalValue} from '@lexical/react/useExtensionSignalValue';
+ * import {MyExtension} from './MyExtension';
+ *
+ * function MyComponent() {
+ *   // Assuming MyExtension has a signal property 'count' in its output
+ *   const count = useExtensionSignalValue(MyExtension, 'count');
+ *   return <div>Count: {count}</div>;
+ * }
+ * ```
+ */
+function useExtensionSignalValue(extension, prop) {
+  const signal = useExtensionDependency(extension).output[prop];
+  return useSignalValue(signal);
+}
+
+export { useExtensionSignalValue, useSignalValue };

package/useLexicalExtensionSignalValue.js

@@ -0,0 +1,11 @@
+/**
+ * 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 useLexicalExtensionSignalValue = process.env.NODE_ENV !== 'production' ? require('./useLexicalExtensionSignalValue.dev.js') : require('./useLexicalExtensionSignalValue.prod.js');
+module.exports = useLexicalExtensionSignalValue;

package/useLexicalExtensionSignalValue.js.flow

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+import type {ReadonlySignal} from '@lexical/extension';
+import type {AnyLexicalExtension} from 'lexical';
+
+declare export function useSignalValue<V>(s: ReadonlySignal<V>): V;
+
+declare export function useExtensionSignalValue<V>(
+  extension: AnyLexicalExtension,
+  prop: string,
+): V;

package/useLexicalExtensionSignalValue.mjs

@@ -0,0 +1,13 @@
+/**
+ * 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 * as modDev from './useLexicalExtensionSignalValue.dev.mjs';
+import * as modProd from './useLexicalExtensionSignalValue.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const useExtensionSignalValue = mod.useExtensionSignalValue;
+export const useSignalValue = mod.useSignalValue;

package/useLexicalExtensionSignalValue.node.mjs

@@ -0,0 +1,11 @@
+/**
+ * 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 mod = await (process.env.NODE_ENV !== 'production' ? import('./useLexicalExtensionSignalValue.dev.mjs') : import('./useLexicalExtensionSignalValue.prod.mjs'));
+export const useExtensionSignalValue = mod.useExtensionSignalValue;
+export const useSignalValue = mod.useSignalValue;

package/useLexicalExtensionSignalValue.prod.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";var e=require("@lexical/react/useExtensionComponent"),n=require("react");function t(e){const[t,u]=n.useMemo(()=>[e.subscribe.bind(e),e.peek.bind(e)],[e]);return n.useSyncExternalStore(t,u,u)}exports.useExtensionSignalValue=function(n,u){return t(e.useExtensionDependency(n).output[u])},exports.useSignalValue=t;

package/useLexicalExtensionSignalValue.prod.mjs

@@ -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.
+ *
+ */
+
+import{useExtensionDependency as t}from"@lexical/react/useExtensionComponent";import{useMemo as n,useSyncExternalStore as e}from"react";function o(t){const[o,r]=n(()=>[t.subscribe.bind(t),t.peek.bind(t)],[t]);return e(o,r,r)}function r(n,e){return o(t(n).output[e])}export{r as useExtensionSignalValue,o as useSignalValue};

package/useLexicalTextEntity.js.flow

@@ -11,7 +11,7 @@ import type {TextNode} from 'lexical';
 
 export type EntityMatch = {end: number, start: number};
 
-declare export function useLexicalTextEntity<N: TextNode>(
+declare export function useLexicalTextEntity<N extends TextNode>(
   getMatch: (text: string) => null | EntityMatch,
   targetNode: Class<N>,
   createNode: (textNode: TextNode) => N,

package/LexicalContextMenuPlugin.d.ts

@@ -1,42 +0,0 @@
-/**
- * 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 { MenuRenderFn, MenuResolution } from './shared/LexicalMenu';
-import type { JSX } from 'react';
-import { CommandListenerPriority, LexicalNode } from 'lexical';
-import { ReactPortal, RefObject } from 'react';
-import { MenuOption } from './shared/LexicalMenu';
-export type ContextMenuRenderFn<TOption extends MenuOption> = (anchorElementRef: RefObject<HTMLElement | null>, itemProps: {
-    selectedIndex: number | null;
-    selectOptionAndCleanUp: (option: TOption) => void;
-    setHighlightedIndex: (index: number) => void;
-    options: Array<TOption>;
-}, menuProps: {
-    setMenuRef: (element: HTMLElement | null) => void;
-}) => ReactPortal | JSX.Element | null;
-export type LexicalContextMenuPluginProps<TOption extends MenuOption> = {
-    onSelectOption: (option: TOption, textNodeContainingQuery: LexicalNode | null, closeMenu: () => void, matchingString: string) => void;
-    options: Array<TOption>;
-    onClose?: () => void;
-    onWillOpen?: (event: MouseEvent) => void;
-    onOpen?: (resolution: MenuResolution) => void;
-    /**
-     * @deprecated Use LexicalNodeContextMenuPlugin instead. Here is an example for using NodeContextMenuPlugin:
-     * https://github.com/facebook/lexical/blob/main/packages/lexical-playground/src/plugins/ContextMenuPlugin/index.tsx
-     */
-    menuRenderFn: ContextMenuRenderFn<TOption>;
-    anchorClassName?: string;
-    commandPriority?: CommandListenerPriority;
-    parent?: HTMLElement;
-};
-/**
- * @deprecated Use LexicalNodeContextMenuPlugin instead. It will be removed soon.
- * Here is an example for using NodeContextMenuPlugin:
- * https://github.com/facebook/lexical/blob/main/packages/lexical-playground/src/plugins/ContextMenuPlugin/index.tsx
- */
-export declare function LexicalContextMenuPlugin<TOption extends MenuOption>({ options, onWillOpen, onClose, onOpen, onSelectOption, menuRenderFn: contextMenuRenderFn, anchorClassName, commandPriority, parent, }: LexicalContextMenuPluginProps<TOption>): JSX.Element | null;
-export { MenuOption, MenuRenderFn, MenuResolution };