zurfyx-lexical-react 0.39.1-nightly.20251225.0

package/npm/useLexicalEditable.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 useLexicalEditable = process.env.NODE_ENV !== 'production' ? require('./useLexicalEditable.dev.js') : require('./useLexicalEditable.prod.js');
+module.exports = useLexicalEditable;

package/npm/useLexicalEditable.js.flow

@@ -0,0 +1,12 @@
+/**
+ * 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 {LexicalEditor} from 'lexical';
+
+declare export function useLexicalEditable(): boolean;

package/npm/useLexicalEditable.mjs

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

package/npm/useLexicalEditable.node.mjs

@@ -0,0 +1,10 @@
+/**
+ * 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('./useLexicalEditable.dev.mjs') : import('./useLexicalEditable.prod.mjs'));
+export const useLexicalEditable = mod.useLexicalEditable;

package/npm/useLexicalEditable.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/LexicalComposerContext"),t=require("react");const i="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement?t.useLayoutEffect:t.useEffect;function n(e){return{initialValueFn:()=>e.isEditable(),subscribe:t=>e.registerEditableListener(t)}}exports.useLexicalEditable=function(){return function(n){const[r]=e.useLexicalComposerContext(),u=t.useMemo(()=>n(r),[r,n]),[c,o]=t.useState(()=>u.initialValueFn()),s=t.useRef(c);return i(()=>{const{initialValueFn:e,subscribe:t}=u,i=e();return s.current!==i&&(s.current=i,o(i)),t(e=>{s.current=e,o(e)})},[u,n]),c}(n)};

package/npm/useLexicalEditable.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{useLexicalComposerContext as e}from"@lexical/react/LexicalComposerContext";import{useLayoutEffect as n,useEffect as t,useMemo as i,useState as r,useRef as o}from"react";const c="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement?n:t;function u(e){return{initialValueFn:()=>e.isEditable(),subscribe:n=>e.registerEditableListener(n)}}function a(){return function(n){const[t]=e(),u=i(()=>n(t),[t,n]),[a,l]=r(()=>u.initialValueFn()),d=o(a);return c(()=>{const{initialValueFn:e,subscribe:n}=u,t=e();return d.current!==t&&(d.current=t,l(t)),n(e=>{d.current=e,l(e)})},[u,n]),a}(u)}export{a as useLexicalEditable};

package/npm/useLexicalExtensionComponent.dev.js

@@ -0,0 +1,37 @@
+/**
+ * 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 extension = require('@lexical/extension');
+var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+
+/**
+ * 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.
+ *
+ */
+function useExtensionDependency(extension$1) {
+  return extension.getExtensionDependencyFromEditor(LexicalComposerContext.useLexicalComposerContext()[0], extension$1);
+}
+
+/**
+ * Use a Component from the given Extension that uses the ReactExtension convention
+ * of exposing a Component property in its output.
+ *
+ * @param extension - An extension with a Component property in the output
+ * @returns `getExtensionConfigFromEditor(useLexicalComposerContext()[0], extension).Component`
+ */
+function useExtensionComponent(extension) {
+  return useExtensionDependency(extension).output.Component;
+}
+
+exports.useExtensionComponent = useExtensionComponent;
+exports.useExtensionDependency = useExtensionDependency;

package/npm/useLexicalExtensionComponent.dev.mjs

@@ -0,0 +1,34 @@
+/**
+ * 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 { getExtensionDependencyFromEditor } from '@lexical/extension';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+
+/**
+ * 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.
+ *
+ */
+function useExtensionDependency(extension) {
+  return getExtensionDependencyFromEditor(useLexicalComposerContext()[0], extension);
+}
+
+/**
+ * Use a Component from the given Extension that uses the ReactExtension convention
+ * of exposing a Component property in its output.
+ *
+ * @param extension - An extension with a Component property in the output
+ * @returns `getExtensionConfigFromEditor(useLexicalComposerContext()[0], extension).Component`
+ */
+function useExtensionComponent(extension) {
+  return useExtensionDependency(extension).output.Component;
+}
+
+export { useExtensionComponent, useExtensionDependency };

package/npm/useLexicalExtensionComponent.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 useLexicalExtensionComponent = process.env.NODE_ENV !== 'production' ? require('./useLexicalExtensionComponent.dev.js') : require('./useLexicalExtensionComponent.prod.js');
+module.exports = useLexicalExtensionComponent;

package/npm/useLexicalExtensionComponent.js.flow

@@ -0,0 +1,12 @@
+/**
+ * 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
+ */
+
+/**
+ * useLexicalExtensionComponent
+ */

package/npm/useLexicalExtensionComponent.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 './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;

package/npm/useLexicalExtensionComponent.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('./useLexicalExtensionComponent.dev.mjs') : import('./useLexicalExtensionComponent.prod.mjs'));
+export const useExtensionComponent = mod.useExtensionComponent;
+export const useExtensionDependency = mod.useExtensionDependency;

package/npm/useLexicalExtensionComponent.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/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;

package/npm/useLexicalExtensionComponent.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{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};

package/npm/useLexicalIsTextContentEmpty.d.ts

@@ -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 type { LexicalEditor } from 'lexical';
+export declare function useLexicalIsTextContentEmpty(editor: LexicalEditor, trim?: boolean): boolean;

package/npm/useLexicalIsTextContentEmpty.dev.js

@@ -0,0 +1,60 @@
+/**
+ * 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 text = require('@lexical/text');
+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 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.
+ *
+ */
+
+
+// This workaround is no longer necessary in React 19,
+// but we currently support React >=17.x
+// https://github.com/facebook/react/pull/26395
+const useLayoutEffectImpl = CAN_USE_DOM ? react.useLayoutEffect : react.useEffect;
+
+/**
+ * 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.
+ *
+ */
+
+function useLexicalIsTextContentEmpty(editor, trim) {
+  const [isEmpty, setIsEmpty] = react.useState(editor.getEditorState().read(text.$isRootTextContentEmptyCurry(editor.isComposing(), trim)));
+  useLayoutEffectImpl(() => {
+    return editor.registerUpdateListener(({
+      editorState
+    }) => {
+      const isComposing = editor.isComposing();
+      const currentIsEmpty = editorState.read(text.$isRootTextContentEmptyCurry(isComposing, trim));
+      setIsEmpty(currentIsEmpty);
+    });
+  }, [editor, trim]);
+  return isEmpty;
+}
+
+exports.useLexicalIsTextContentEmpty = useLexicalIsTextContentEmpty;

package/npm/useLexicalIsTextContentEmpty.dev.mjs

@@ -0,0 +1,58 @@
+/**
+ * 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 { $isRootTextContentEmptyCurry } from '@lexical/text';
+import { useLayoutEffect, useEffect, useState } 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.
+ *
+ */
+
+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.
+ *
+ */
+
+
+// This workaround is no longer necessary in React 19,
+// but we currently support React >=17.x
+// https://github.com/facebook/react/pull/26395
+const useLayoutEffectImpl = CAN_USE_DOM ? useLayoutEffect : useEffect;
+
+/**
+ * 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.
+ *
+ */
+
+function useLexicalIsTextContentEmpty(editor, trim) {
+  const [isEmpty, setIsEmpty] = useState(editor.getEditorState().read($isRootTextContentEmptyCurry(editor.isComposing(), trim)));
+  useLayoutEffectImpl(() => {
+    return editor.registerUpdateListener(({
+      editorState
+    }) => {
+      const isComposing = editor.isComposing();
+      const currentIsEmpty = editorState.read($isRootTextContentEmptyCurry(isComposing, trim));
+      setIsEmpty(currentIsEmpty);
+    });
+  }, [editor, trim]);
+  return isEmpty;
+}
+
+export { useLexicalIsTextContentEmpty };

package/npm/useLexicalIsTextContentEmpty.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 useLexicalIsTextContentEmpty = process.env.NODE_ENV !== 'production' ? require('./useLexicalIsTextContentEmpty.dev.js') : require('./useLexicalIsTextContentEmpty.prod.js');
+module.exports = useLexicalIsTextContentEmpty;

package/npm/useLexicalIsTextContentEmpty.js.flow

@@ -0,0 +1,15 @@
+/**
+ * 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 {LexicalEditor} from 'lexical';
+
+declare export function useLexicalIsTextContentEmpty(
+  editor: LexicalEditor,
+  trim?: boolean,
+): boolean;

package/npm/useLexicalIsTextContentEmpty.mjs

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

package/npm/useLexicalIsTextContentEmpty.node.mjs

@@ -0,0 +1,10 @@
+/**
+ * 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('./useLexicalIsTextContentEmpty.dev.mjs') : import('./useLexicalIsTextContentEmpty.prod.mjs'));
+export const useLexicalIsTextContentEmpty = mod.useLexicalIsTextContentEmpty;

package/npm/useLexicalIsTextContentEmpty.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 t=require("@lexical/text"),e=require("react");const o="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement?e.useLayoutEffect:e.useEffect;exports.useLexicalIsTextContentEmpty=function(n,i){const[r,s]=e.useState(n.getEditorState().read(t.$isRootTextContentEmptyCurry(n.isComposing(),i)));return o(()=>n.registerUpdateListener(({editorState:e})=>{const o=n.isComposing(),r=e.read(t.$isRootTextContentEmptyCurry(o,i));s(r)}),[n,i]),r};

package/npm/useLexicalIsTextContentEmpty.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{$isRootTextContentEmptyCurry as t}from"@lexical/text";import{useLayoutEffect as e,useEffect as o,useState as i}from"react";const n="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement?e:o;function r(e,o){const[r,d]=i(e.getEditorState().read(t(e.isComposing(),o)));return n(()=>e.registerUpdateListener(({editorState:i})=>{const n=e.isComposing(),r=i.read(t(n,o));d(r)}),[e,o]),r}export{r as useLexicalIsTextContentEmpty};

package/npm/useLexicalNodeSelection.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { NodeKey } from 'lexical';
+/**
+ * A custom hook to manage the selection state of a specific node in a Lexical editor.
+ *
+ * This hook provides utilities to:
+ * - Check if a node is selected.
+ * - Update its selection state.
+ * - Clear the selection.
+ *
+ * @param {NodeKey} key - The key of the node to track selection for.
+ * @returns {[boolean, (selected: boolean) => void, () => void]} A tuple containing:
+ * - `isSelected` (boolean): Whether the node is currently selected.
+ * - `setSelected` (function): A function to set the selection state of the node.
+ * - `clearSelected` (function): A function to clear the selection of the node.
+ *
+ */
+export declare function useLexicalNodeSelection(key: NodeKey): [boolean, (selected: boolean) => void, () => void];

package/npm/useLexicalNodeSelection.dev.js

@@ -0,0 +1,102 @@
+/**
+ * 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 LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var lexical = require('lexical');
+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 helper function to determine if a specific node is selected in a Lexical editor.
+ *
+ * @param {LexicalEditor} editor - The LexicalEditor instance.
+ * @param {NodeKey} key - The key of the node to check.
+ * @returns {boolean} Whether the node is selected.
+ */
+
+function isNodeSelected(editor, key) {
+  return editor.getEditorState().read(() => {
+    const node = lexical.$getNodeByKey(key);
+    if (node === null) {
+      return false; // Node doesn't exist, so it's not selected.
+    }
+    return node.isSelected(); // Check if the node is selected.
+  });
+}
+
+/**
+ * A custom hook to manage the selection state of a specific node in a Lexical editor.
+ *
+ * This hook provides utilities to:
+ * - Check if a node is selected.
+ * - Update its selection state.
+ * - Clear the selection.
+ *
+ * @param {NodeKey} key - The key of the node to track selection for.
+ * @returns {[boolean, (selected: boolean) => void, () => void]} A tuple containing:
+ * - `isSelected` (boolean): Whether the node is currently selected.
+ * - `setSelected` (function): A function to set the selection state of the node.
+ * - `clearSelected` (function): A function to clear the selection of the node.
+ *
+ */
+
+function useLexicalNodeSelection(key) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+
+  // State to track whether the node is currently selected.
+  const [isSelected, setIsSelected] = react.useState(() => isNodeSelected(editor, key));
+  react.useEffect(() => {
+    let isMounted = true;
+    const unregister = editor.registerUpdateListener(() => {
+      if (isMounted) {
+        setIsSelected(isNodeSelected(editor, key));
+      }
+    });
+    return () => {
+      isMounted = false; // Prevent updates after component unmount.
+      unregister();
+    };
+  }, [editor, key]);
+  const setSelected = react.useCallback(selected => {
+    editor.update(() => {
+      let selection = lexical.$getSelection();
+      if (!lexical.$isNodeSelection(selection)) {
+        selection = lexical.$createNodeSelection();
+        lexical.$setSelection(selection);
+      }
+      if (lexical.$isNodeSelection(selection)) {
+        if (selected) {
+          selection.add(key);
+        } else {
+          selection.delete(key);
+        }
+      }
+    });
+  }, [editor, key]);
+  const clearSelected = react.useCallback(() => {
+    editor.update(() => {
+      const selection = lexical.$getSelection();
+      if (lexical.$isNodeSelection(selection)) {
+        selection.clear();
+      }
+    });
+  }, [editor]);
+  return [isSelected, setSelected, clearSelected];
+}
+
+exports.useLexicalNodeSelection = useLexicalNodeSelection;

package/npm/useLexicalNodeSelection.dev.mjs

@@ -0,0 +1,100 @@
+/**
+ * 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 { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getSelection, $isNodeSelection, $createNodeSelection, $setSelection, $getNodeByKey } from 'lexical';
+import { useState, useEffect, useCallback } 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 helper function to determine if a specific node is selected in a Lexical editor.
+ *
+ * @param {LexicalEditor} editor - The LexicalEditor instance.
+ * @param {NodeKey} key - The key of the node to check.
+ * @returns {boolean} Whether the node is selected.
+ */
+
+function isNodeSelected(editor, key) {
+  return editor.getEditorState().read(() => {
+    const node = $getNodeByKey(key);
+    if (node === null) {
+      return false; // Node doesn't exist, so it's not selected.
+    }
+    return node.isSelected(); // Check if the node is selected.
+  });
+}
+
+/**
+ * A custom hook to manage the selection state of a specific node in a Lexical editor.
+ *
+ * This hook provides utilities to:
+ * - Check if a node is selected.
+ * - Update its selection state.
+ * - Clear the selection.
+ *
+ * @param {NodeKey} key - The key of the node to track selection for.
+ * @returns {[boolean, (selected: boolean) => void, () => void]} A tuple containing:
+ * - `isSelected` (boolean): Whether the node is currently selected.
+ * - `setSelected` (function): A function to set the selection state of the node.
+ * - `clearSelected` (function): A function to clear the selection of the node.
+ *
+ */
+
+function useLexicalNodeSelection(key) {
+  const [editor] = useLexicalComposerContext();
+
+  // State to track whether the node is currently selected.
+  const [isSelected, setIsSelected] = useState(() => isNodeSelected(editor, key));
+  useEffect(() => {
+    let isMounted = true;
+    const unregister = editor.registerUpdateListener(() => {
+      if (isMounted) {
+        setIsSelected(isNodeSelected(editor, key));
+      }
+    });
+    return () => {
+      isMounted = false; // Prevent updates after component unmount.
+      unregister();
+    };
+  }, [editor, key]);
+  const setSelected = useCallback(selected => {
+    editor.update(() => {
+      let selection = $getSelection();
+      if (!$isNodeSelection(selection)) {
+        selection = $createNodeSelection();
+        $setSelection(selection);
+      }
+      if ($isNodeSelection(selection)) {
+        if (selected) {
+          selection.add(key);
+        } else {
+          selection.delete(key);
+        }
+      }
+    });
+  }, [editor, key]);
+  const clearSelected = useCallback(() => {
+    editor.update(() => {
+      const selection = $getSelection();
+      if ($isNodeSelection(selection)) {
+        selection.clear();
+      }
+    });
+  }, [editor]);
+  return [isSelected, setSelected, clearSelected];
+}
+
+export { useLexicalNodeSelection };

package/npm/useLexicalNodeSelection.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 useLexicalNodeSelection = process.env.NODE_ENV !== 'production' ? require('./useLexicalNodeSelection.dev.js') : require('./useLexicalNodeSelection.prod.js');
+module.exports = useLexicalNodeSelection;