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

package/LexicalAutoFocusPlugin.js.flow

@@ -7,7 +7,7 @@
  * @flow strict
  */
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   defaultSelection?: 'rootStart' | 'rootEnd',
 }>;
 

package/LexicalBlockWithAlignableContents.js.flow

@@ -15,11 +15,11 @@ import type {
   NodeKey,
 } from 'lexical';
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   children: React.Node,
   format: ?ElementFormatType,
   nodeKey: NodeKey,
-  className: $ReadOnly<{
+  className: Readonly<{
     base: string,
     focus: string,
   }>,

package/LexicalClearEditorPlugin.js.flow

@@ -7,7 +7,7 @@
  * @flow strict
  */
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   onClear?: () => void,
 }>;
 

package/LexicalComposer.js.flow

@@ -22,10 +22,10 @@ export type InitialEditorStateType =
   | EditorState
   | ((editor: LexicalEditor) => void);
 
-export type InitialConfigType = $ReadOnly<{
+export type InitialConfigType = Readonly<{
   editable?: boolean,
   namespace: string,
-  nodes?: $ReadOnlyArray<Class<LexicalNode> | LexicalNodeReplacement>,
+  nodes?: ReadonlyArray<Class<LexicalNode> | LexicalNodeReplacement>,
   theme?: EditorThemeClasses,
   editorState?: InitialEditorStateType,
   onError: (error: Error, editor: LexicalEditor) => void,

package/LexicalContentEditable.js.flow

@@ -14,11 +14,11 @@ import type {TRefFor} from 'CoreTypes.flow';
 import * as React from 'react';
 
 type InlineStyle = {
-  [key: string]: mixed,
+  [key: string]: unknown,
 };
 
 // Due to Flow limitations, we prefer fixed types over the built-in inexact HTMLElement
-type HTMLDivElementDOMProps = $ReadOnly<{
+type HTMLDivElementDOMProps = Readonly<{
   'aria-label'?: void | string,
   'aria-labeledby'?: void | string,
   'aria-activedescendant'?: void | string,
@@ -28,7 +28,7 @@ type HTMLDivElementDOMProps = $ReadOnly<{
   'aria-invalid'?: void | boolean,
   'aria-owns'?: void | string,
   'title'?: void | string,
-  onClick?: void | ((e: SyntheticEvent<HTMLDivElement>) => mixed),
+  onClick?: void | ((e: SyntheticEvent<HTMLDivElement>) => unknown),
   autoCapitalize?: void | boolean,
   autoComplete?: void | boolean,
   autoCorrect?: void | boolean,
@@ -44,11 +44,11 @@ type HTMLDivElementDOMProps = $ReadOnly<{
 }>;
 
 export type PlaceholderProps =
-  | $ReadOnly<{
+  | Readonly<{
       'aria-placeholder'?: void,
       placeholder?: null,
     }>
-  | $ReadOnly<{
+  | Readonly<{
       'aria-placeholder': string,
       placeholder:
         | ((isEditable: boolean) => null | React.Node)
@@ -56,7 +56,7 @@ export type PlaceholderProps =
         | React.Node,
     }>;
 
-export type Props = $ReadOnly<{
+export type Props = Readonly<{
   ...HTMLDivElementDOMProps,
   ariaActiveDescendant?: string,
   ariaAutoComplete?: string,

package/LexicalDraggableBlockPlugin.js.flow

@@ -9,7 +9,7 @@
 
 import * as React from 'react';
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   anchorElem?: ?HTMLElement,
   menuRef: React.RefObject<?HTMLElement>,
   targetLineRef: React.RefObject<?HTMLElement>,

package/LexicalEditorRefPlugin.d.ts

@@ -6,8 +6,8 @@
  *
  */
 import { LexicalEditor } from 'lexical';
-import { RefObject } from 'react';
 import * as React from 'react';
+import { RefObject } from 'react';
 /**
  *
  * Use this plugin to access the editor instance outside of the

package/LexicalEditorRefPlugin.dev.js

@@ -32,7 +32,6 @@ var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
  *
  */
 
-
 /**
  *
  * Use this plugin to access the editor instance outside of the

package/LexicalEditorRefPlugin.dev.mjs

@@ -17,7 +17,6 @@ import * as React from 'react';
  *
  */
 
-
 /**
  *
  * Use this plugin to access the editor instance outside of the

package/LexicalEditorRefPlugin.js.flow

@@ -12,7 +12,7 @@ import type {LexicalEditor} from 'lexical';
 import type {TRefFor} from 'CoreTypes.flow';
 
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   editorRef: TRefFor<LexicalEditor>,
 }>;
 

package/LexicalErrorBoundary.js.flow

@@ -7,7 +7,7 @@
  * @flow strict
  */
 
-export type LexicalErrorBoundaryProps = $ReadOnly<{
+export type LexicalErrorBoundaryProps = Readonly<{
   children: React.Node,
   onError: (error: Error) => void,
 }>;

package/LexicalHorizontalRulePlugin.js.flow

@@ -7,6 +7,6 @@
  * @flow strict
  */
 
-type Props = $ReadOnly<{}>;
+type Props = Readonly<{}>;
 
 declare export function HorizontalRulePlugin(props: Props): null;

package/LexicalLinkPlugin.js.flow

@@ -13,7 +13,7 @@ type LinkAttributes = {
   title?: null | string;
 };
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   validateUrl?: (url: string) => boolean,
   attributes?: LinkAttributes,
 }>;

package/LexicalNestedComposer.js.flow

@@ -18,7 +18,7 @@ export type LexicalNestedComposerProps = {
   children?: React.Node;
   initialEditor: LexicalEditor;
   initialTheme?: EditorThemeClasses;
-  initialNodes?: $ReadOnlyArray<Class<LexicalNode> | LexicalNodeReplacement>;
+  initialNodes?: ReadonlyArray<Class<LexicalNode> | LexicalNodeReplacement>;
   skipCollabChecks?: void | true;
   skipEditableListener?: void | true;
 };

package/LexicalPlainTextPlugin.dev.js

@@ -183,9 +183,6 @@ function useCanShowPlaceholder(editor) {
 function usePlainTextSetup(editor) {
   useLayoutEffectImpl(() => {
     return utils.mergeRegister(plainText.registerPlainText(editor), dragon.registerDragonSupport(editor));
-
-    // We only do this for init
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor]);
 }
 

package/LexicalPlainTextPlugin.dev.mjs

@@ -181,9 +181,6 @@ function useCanShowPlaceholder(editor) {
 function usePlainTextSetup(editor) {
   useLayoutEffectImpl(() => {
     return mergeRegister(registerPlainText(editor), registerDragonSupport(editor));
-
-    // We only do this for init
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor]);
 }
 

package/LexicalReactExtension.dev.js

@@ -91,9 +91,7 @@ function buildEditorComponent(config, context) {
     const configDecorators = react.useMemo(() => rawConfigDecorators.map((decorator, i) => /*#__PURE__*/jsxRuntime.jsx(ErrorBoundary, {
       onError: e => {
         editor._onError(e);
-      }
-      // eslint-disable-next-line react/no-array-index-key -- no natural key
-      ,
+      },
       children: /*#__PURE__*/jsxRuntime.jsx(react.Suspense, {
         fallback: null,
         children: decorator

package/LexicalReactExtension.dev.mjs

@@ -89,9 +89,7 @@ function buildEditorComponent(config, context) {
     const configDecorators = useMemo(() => rawConfigDecorators.map((decorator, i) => /*#__PURE__*/jsx(ErrorBoundary, {
       onError: e => {
         editor._onError(e);
-      }
-      // eslint-disable-next-line react/no-array-index-key -- no natural key
-      ,
+      },
       children: /*#__PURE__*/jsx(Suspense, {
         fallback: null,
         children: decorator

package/LexicalReactExtension.js.flow

@@ -46,7 +46,7 @@ export type ReactConfig = {
   contentEditable: React.Node | null;
   ErrorBoundary: ErrorBoundaryType;
   EditorChildrenComponent: EditorChildrenComponentType;
-  decorators: $ReadOnlyArray<DecoratorComponentType>;
+  decorators: ReadonlyArray<DecoratorComponentType>;
 };
 
 export type ReactOutputs = {

package/LexicalReactPluginHostExtension.js.flow

@@ -24,7 +24,7 @@ export type {DecoratorComponentProps};
 
 type Container = DocumentFragment | Element;
 // TODO: Not sure how to import RootType from react-dom/client
-type Root = mixed;
+type Root = unknown;
 
 export interface HostMountCommandArg {
   root: Root;
@@ -37,7 +37,7 @@ export interface MountPluginCommandArg {
 }
 
 declare export function mountReactExtensionComponent<
-  Extension: AnyLexicalExtension,
+  Extension extends AnyLexicalExtension,
 >(
   editor: LexicalEditor,
   opts: {
@@ -54,7 +54,7 @@ declare export function mountReactExtensionComponent<
 ): void;
 
 declare export function mountReactPluginComponent<
-  P: {...} = {...},
+  P extends {...} = {...},
 >(
   editor: LexicalEditor,
   opts: {

package/LexicalRichTextPlugin.dev.js

@@ -183,9 +183,6 @@ function useCanShowPlaceholder(editor) {
 function useRichTextSetup(editor) {
   useLayoutEffectImpl(() => {
     return utils.mergeRegister(richText.registerRichText(editor), dragon.registerDragonSupport(editor));
-
-    // We only do this for init
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor]);
 }
 

package/LexicalRichTextPlugin.dev.mjs

@@ -181,9 +181,6 @@ function useCanShowPlaceholder(editor) {
 function useRichTextSetup(editor) {
   useLayoutEffectImpl(() => {
     return mergeRegister(registerRichText(editor), registerDragonSupport(editor));
-
-    // We only do this for init
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor]);
 }
 

package/LexicalTabIndentationPlugin.js.flow

@@ -14,7 +14,7 @@ declare export function registerTabIndentation(
   maxIndent?: number,
 ): () => void;
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   maxIndent?: number,
 }>;
 

package/LexicalTablePlugin.js.flow

@@ -7,7 +7,7 @@
  * @flow strict
  */
 
-type Props = $ReadOnly<{
+type Props = Readonly<{
   hasCellMerge?: boolean,
   hasCellBackgroundColor?: boolean,
   hasTabHandler?: boolean,

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/lexical__react
 
 | Field | Value |
 |-------|-------|
-| Original | [@lexical/react](https://www.npmjs.com/package/@lexical/react) @ 0.42.0 |
-| Processed | 2026-03-20 |
+| Original | [@lexical/react](https://www.npmjs.com/package/@lexical/react) @ 0.43.0 |
+| Processed | 2026-04-09 |
 | Smoke test | failed |
 | Deps updated | 2 |
 

package/changes.json

@@ -9,6 +9,6 @@
       "to": "^6.1.1"
     }
   },
-  "timestamp": "2026-03-20T00:35:04.264Z",
+  "timestamp": "2026-04-09T20:22:32.773Z",
   "totalUpdated": 2
 }

package/package.json

@@ -14,26 +14,26 @@
     "rich-text"
   ],
   "license": "MIT",
-  "version": "0.42.0-depup.0",
+  "version": "0.43.0-depup.0",
   "dependencies": {
     "@floating-ui/react": "^0.27.19",
-    "@lexical/devtools-core": "0.42.0",
-    "@lexical/dragon": "0.42.0",
-    "@lexical/extension": "0.42.0",
-    "@lexical/hashtag": "0.42.0",
-    "@lexical/history": "0.42.0",
-    "@lexical/link": "0.42.0",
-    "@lexical/list": "0.42.0",
-    "@lexical/mark": "0.42.0",
-    "@lexical/markdown": "0.42.0",
-    "@lexical/overflow": "0.42.0",
-    "@lexical/plain-text": "0.42.0",
-    "@lexical/rich-text": "0.42.0",
-    "@lexical/table": "0.42.0",
-    "@lexical/text": "0.42.0",
-    "@lexical/utils": "0.42.0",
-    "@lexical/yjs": "0.42.0",
-    "lexical": "0.42.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": {
@@ -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.42.0",
-    "processedAt": "2026-03-20T00:35:10.564Z",
+    "originalVersion": "0.43.0",
+    "processedAt": "2026-04-09T20:22:39.300Z",
     "smokeTest": "failed"
   }
 }

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/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,