zurfyx-lexical-react 0.39.1-nightly.20251225.0

package/npm/LexicalComposer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { JSX } from 'react';
+import { EditorState, EditorThemeClasses, HTMLConfig, Klass, LexicalEditor, LexicalNode, LexicalNodeReplacement } from 'lexical';
+import * as React from 'react';
+export type InitialEditorStateType = null | string | EditorState | ((editor: LexicalEditor) => void);
+export type InitialConfigType = Readonly<{
+    namespace: string;
+    nodes?: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;
+    onError: (error: Error, editor: LexicalEditor) => void;
+    editable?: boolean;
+    theme?: EditorThemeClasses;
+    editorState?: InitialEditorStateType;
+    html?: HTMLConfig;
+}>;
+type Props = React.PropsWithChildren<{
+    initialConfig: InitialConfigType;
+}>;
+export declare function LexicalComposer({ initialConfig, children }: Props): JSX.Element;
+export {};

package/npm/LexicalComposer.dev.js

@@ -0,0 +1,134 @@
+/**
+ * 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');
+var jsxRuntime = require('react/jsx-runtime');
+
+/**
+ * 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.
+ *
+ */
+
+const HISTORY_MERGE_OPTIONS = {
+  tag: lexical.HISTORY_MERGE_TAG
+};
+function LexicalComposer({
+  initialConfig,
+  children
+}) {
+  const composerContext = react.useMemo(() => {
+    const {
+      theme,
+      namespace,
+      nodes,
+      onError,
+      editorState: initialEditorState,
+      html
+    } = initialConfig;
+    const context = LexicalComposerContext.createLexicalComposerContext(null, theme);
+    const editor = lexical.createEditor({
+      editable: initialConfig.editable,
+      html,
+      namespace,
+      nodes,
+      onError: error => onError(error, editor),
+      theme
+    });
+    initializeEditor(editor, initialEditorState);
+    return [editor, context];
+  },
+  // We only do this for init
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+  useLayoutEffectImpl(() => {
+    const isEditable = initialConfig.editable;
+    const [editor] = composerContext;
+    editor.setEditable(isEditable !== undefined ? isEditable : true);
+
+    // We only do this for init
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return /*#__PURE__*/jsxRuntime.jsx(LexicalComposerContext.LexicalComposerContext.Provider, {
+    value: composerContext,
+    children: children
+  });
+}
+function initializeEditor(editor, initialEditorState) {
+  if (initialEditorState === null) {
+    return;
+  } else if (initialEditorState === undefined) {
+    editor.update(() => {
+      const root = lexical.$getRoot();
+      if (root.isEmpty()) {
+        const paragraph = lexical.$createParagraphNode();
+        root.append(paragraph);
+        const activeElement = CAN_USE_DOM ? document.activeElement : null;
+        if (lexical.$getSelection() !== null || activeElement !== null && activeElement === editor.getRootElement()) {
+          paragraph.select();
+        }
+      }
+    }, HISTORY_MERGE_OPTIONS);
+  } else if (initialEditorState !== null) {
+    switch (typeof initialEditorState) {
+      case 'string':
+        {
+          const parsedEditorState = editor.parseEditorState(initialEditorState);
+          editor.setEditorState(parsedEditorState, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+      case 'object':
+        {
+          editor.setEditorState(initialEditorState, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+      case 'function':
+        {
+          editor.update(() => {
+            const root = lexical.$getRoot();
+            if (root.isEmpty()) {
+              initialEditorState(editor);
+            }
+          }, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+    }
+  }
+}
+
+exports.LexicalComposer = LexicalComposer;

package/npm/LexicalComposer.dev.mjs

@@ -0,0 +1,132 @@
+/**
+ * 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 { createLexicalComposerContext, LexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { createEditor, $getRoot, $createParagraphNode, $getSelection, HISTORY_MERGE_TAG } from 'lexical';
+import { useLayoutEffect, useEffect, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+/**
+ * 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.
+ *
+ */
+
+const HISTORY_MERGE_OPTIONS = {
+  tag: HISTORY_MERGE_TAG
+};
+function LexicalComposer({
+  initialConfig,
+  children
+}) {
+  const composerContext = useMemo(() => {
+    const {
+      theme,
+      namespace,
+      nodes,
+      onError,
+      editorState: initialEditorState,
+      html
+    } = initialConfig;
+    const context = createLexicalComposerContext(null, theme);
+    const editor = createEditor({
+      editable: initialConfig.editable,
+      html,
+      namespace,
+      nodes,
+      onError: error => onError(error, editor),
+      theme
+    });
+    initializeEditor(editor, initialEditorState);
+    return [editor, context];
+  },
+  // We only do this for init
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+  useLayoutEffectImpl(() => {
+    const isEditable = initialConfig.editable;
+    const [editor] = composerContext;
+    editor.setEditable(isEditable !== undefined ? isEditable : true);
+
+    // We only do this for init
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return /*#__PURE__*/jsx(LexicalComposerContext.Provider, {
+    value: composerContext,
+    children: children
+  });
+}
+function initializeEditor(editor, initialEditorState) {
+  if (initialEditorState === null) {
+    return;
+  } else if (initialEditorState === undefined) {
+    editor.update(() => {
+      const root = $getRoot();
+      if (root.isEmpty()) {
+        const paragraph = $createParagraphNode();
+        root.append(paragraph);
+        const activeElement = CAN_USE_DOM ? document.activeElement : null;
+        if ($getSelection() !== null || activeElement !== null && activeElement === editor.getRootElement()) {
+          paragraph.select();
+        }
+      }
+    }, HISTORY_MERGE_OPTIONS);
+  } else if (initialEditorState !== null) {
+    switch (typeof initialEditorState) {
+      case 'string':
+        {
+          const parsedEditorState = editor.parseEditorState(initialEditorState);
+          editor.setEditorState(parsedEditorState, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+      case 'object':
+        {
+          editor.setEditorState(initialEditorState, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+      case 'function':
+        {
+          editor.update(() => {
+            const root = $getRoot();
+            if (root.isEmpty()) {
+              initialEditorState(editor);
+            }
+          }, HISTORY_MERGE_OPTIONS);
+          break;
+        }
+    }
+  }
+}
+
+export { LexicalComposer };

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

package/npm/LexicalComposer.js.flow

@@ -0,0 +1,40 @@
+/**
+ * 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 {
+  EditorThemeClasses,
+  LexicalEditor,
+  LexicalNode,
+  EditorState,
+  LexicalNodeReplacement,
+  HTMLConfig,
+} from 'lexical';
+
+export type InitialEditorStateType =
+  | null
+  | string
+  | EditorState
+  | ((editor: LexicalEditor) => void);
+
+export type InitialConfigType = $ReadOnly<{
+  editable?: boolean,
+  namespace: string,
+  nodes?: $ReadOnlyArray<Class<LexicalNode> | LexicalNodeReplacement>,
+  theme?: EditorThemeClasses,
+  editorState?: InitialEditorStateType,
+  onError: (error: Error, editor: LexicalEditor) => void,
+  html?: HTMLConfig,
+}>;
+
+type Props = {
+  initialConfig: InitialConfigType,
+  children: React.Node,
+};
+
+declare export function LexicalComposer(Props): React.MixedElement;

package/npm/LexicalComposer.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 './LexicalComposer.dev.mjs';
+import * as modProd from './LexicalComposer.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const LexicalComposer = mod.LexicalComposer;

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

package/npm/LexicalComposer.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("lexical"),o=require("react"),n=require("react/jsx-runtime");const r="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement,i=r?o.useLayoutEffect:o.useEffect,a={tag:t.HISTORY_MERGE_TAG};exports.LexicalComposer=function({initialConfig:c,children:s}){const l=o.useMemo(()=>{const{theme:o,namespace:n,nodes:i,onError:s,editorState:l,html:d}=c,u=e.createLexicalComposerContext(null,o),m=t.createEditor({editable:c.editable,html:d,namespace:n,nodes:i,onError:e=>s(e,m),theme:o});return function(e,o){if(null===o)return;if(void 0===o)e.update(()=>{const o=t.$getRoot();if(o.isEmpty()){const n=t.$createParagraphNode();o.append(n);const i=r?document.activeElement:null;(null!==t.$getSelection()||null!==i&&i===e.getRootElement())&&n.select()}},a);else if(null!==o)switch(typeof o){case"string":{const t=e.parseEditorState(o);e.setEditorState(t,a);break}case"object":e.setEditorState(o,a);break;case"function":e.update(()=>{t.$getRoot().isEmpty()&&o(e)},a)}}(m,l),[m,u]},[]);return i(()=>{const e=c.editable,[t]=l;t.setEditable(void 0===e||e)},[]),n.jsx(e.LexicalComposerContext.Provider,{value:l,children:s})};

package/npm/LexicalComposer.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{createLexicalComposerContext as e,LexicalComposerContext as t}from"@lexical/react/LexicalComposerContext";import{createEditor as o,$getRoot as n,$createParagraphNode as i,$getSelection as r,HISTORY_MERGE_TAG as a}from"lexical";import{useLayoutEffect as c,useEffect as l,useMemo as d}from"react";import{jsx as s}from"react/jsx-runtime";const m="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement,u=m?c:l,p={tag:a};function f({initialConfig:a,children:c}){const l=d(()=>{const{theme:t,namespace:c,nodes:l,onError:d,editorState:s,html:u}=a,f=e(null,t),E=o({editable:a.editable,html:u,namespace:c,nodes:l,onError:e=>d(e,E),theme:t});return function(e,t){if(null===t)return;if(void 0===t)e.update(()=>{const t=n();if(t.isEmpty()){const o=i();t.append(o);const n=m?document.activeElement:null;(null!==r()||null!==n&&n===e.getRootElement())&&o.select()}},p);else if(null!==t)switch(typeof t){case"string":{const o=e.parseEditorState(t);e.setEditorState(o,p);break}case"object":e.setEditorState(t,p);break;case"function":e.update(()=>{n().isEmpty()&&t(e)},p)}}(E,s),[E,f]},[]);return u(()=>{const e=a.editable,[t]=l;t.setEditable(void 0===e||e)},[]),s(t.Provider,{value:l,children:c})}export{f as LexicalComposer};

package/npm/LexicalComposerContext.d.ts

@@ -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.
+ *
+ */
+import type { EditorThemeClasses, LexicalEditor } from 'lexical';
+export type LexicalComposerContextType = {
+    getTheme: () => EditorThemeClasses | null | undefined;
+};
+export type LexicalComposerContextWithEditor = [
+    LexicalEditor,
+    LexicalComposerContextType
+];
+export declare const LexicalComposerContext: React.Context<LexicalComposerContextWithEditor | null | undefined>;
+export declare function createLexicalComposerContext(parent: LexicalComposerContextWithEditor | null | undefined, theme: EditorThemeClasses | null | undefined): LexicalComposerContextType;
+export declare function useLexicalComposerContext(): LexicalComposerContextWithEditor;

package/npm/LexicalComposerContext.dev.js

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
+
+const LexicalComposerContext = /*#__PURE__*/react.createContext(null);
+function createLexicalComposerContext(parent, theme) {
+  let parentContext = null;
+  if (parent != null) {
+    parentContext = parent[1];
+  }
+  function getTheme() {
+    if (theme != null) {
+      return theme;
+    }
+    return parentContext != null ? parentContext.getTheme() : null;
+  }
+  return {
+    getTheme
+  };
+}
+function useLexicalComposerContext() {
+  const composerContext = react.useContext(LexicalComposerContext);
+  if (composerContext == null) {
+    {
+      formatDevErrorMessage(`LexicalComposerContext.useLexicalComposerContext: cannot find a LexicalComposerContext`);
+    }
+  }
+  return composerContext;
+}
+
+exports.LexicalComposerContext = LexicalComposerContext;
+exports.createLexicalComposerContext = createLexicalComposerContext;
+exports.useLexicalComposerContext = useLexicalComposerContext;

package/npm/LexicalComposerContext.dev.mjs

@@ -0,0 +1,51 @@
+/**
+ * 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 { createContext, useContext } 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
+
+const LexicalComposerContext = /*#__PURE__*/createContext(null);
+function createLexicalComposerContext(parent, theme) {
+  let parentContext = null;
+  if (parent != null) {
+    parentContext = parent[1];
+  }
+  function getTheme() {
+    if (theme != null) {
+      return theme;
+    }
+    return parentContext != null ? parentContext.getTheme() : null;
+  }
+  return {
+    getTheme
+  };
+}
+function useLexicalComposerContext() {
+  const composerContext = useContext(LexicalComposerContext);
+  if (composerContext == null) {
+    {
+      formatDevErrorMessage(`LexicalComposerContext.useLexicalComposerContext: cannot find a LexicalComposerContext`);
+    }
+  }
+  return composerContext;
+}
+
+export { LexicalComposerContext, createLexicalComposerContext, useLexicalComposerContext };

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

package/npm/LexicalComposerContext.js.flow

@@ -0,0 +1,27 @@
+/**
+ * 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 {EditorThemeClasses, LexicalEditor} from 'lexical';
+
+export type LexicalComposerContextType = {
+  getTheme: () => ?EditorThemeClasses,
+};
+
+export type LexicalComposerContextWithEditor = [
+  LexicalEditor,
+  LexicalComposerContextType,
+];
+
+declare export var LexicalComposerContext: React.Context<?LexicalComposerContextWithEditor>;
+
+declare export function createLexicalComposerContext(
+  parent: ?LexicalComposerContextWithEditor,
+  theme: ?EditorThemeClasses,
+): LexicalComposerContextType;
+declare export function useLexicalComposerContext(): LexicalComposerContextWithEditor;

package/npm/LexicalComposerContext.mjs

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

package/npm/LexicalComposerContext.node.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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalComposerContext.dev.mjs') : import('./LexicalComposerContext.prod.mjs'));
+export const LexicalComposerContext = mod.LexicalComposerContext;
+export const createLexicalComposerContext = mod.createLexicalComposerContext;
+export const useLexicalComposerContext = mod.useLexicalComposerContext;

package/npm/LexicalComposerContext.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("react");const n=e.createContext(null);exports.LexicalComposerContext=n,exports.createLexicalComposerContext=function(e,n){let t=null;return null!=e&&(t=e[1]),{getTheme:function(){return null!=n?n:null!=t?t.getTheme():null}}},exports.useLexicalComposerContext=function(){const t=e.useContext(n);return null==t&&function(e,...n){const t=new URL("https://lexical.dev/docs/error"),r=new URLSearchParams;r.append("code",e);for(const e of n)r.append("v",e);throw t.search=r.toString(),Error(`Minified Lexical error #${e}; visit ${t.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)}(8),t};

package/npm/LexicalComposerContext.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{createContext as n,useContext as e}from"react";const r=n(null);function t(n,e){let r=null;return null!=n&&(r=n[1]),{getTheme:function(){return null!=e?e:null!=r?r.getTheme():null}}}function o(){const n=e(r);return null==n&&function(n,...e){const r=new URL("https://lexical.dev/docs/error"),t=new URLSearchParams;t.append("code",n);for(const n of e)t.append("v",n);throw r.search=t.toString(),Error(`Minified Lexical error #${n}; visit ${r.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)}(8),n}export{r as LexicalComposerContext,t as createLexicalComposerContext,o as useLexicalComposerContext};

package/npm/LexicalContentEditable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { JSX } from 'react';
+import { ContentEditableElement, type ContentEditableElementProps } from './shared/LexicalContentEditableElement';
+export { ContentEditableElement, type ContentEditableElementProps };
+export type ContentEditableProps = Omit<ContentEditableElementProps, 'editor'> & ({
+    'aria-placeholder'?: void;
+    placeholder?: null;
+} | {
+    'aria-placeholder': string;
+    placeholder: ((isEditable: boolean) => null | JSX.Element) | JSX.Element;
+});
+/**
+ * @deprecated This type has been renamed to `ContentEditableProps` to provide a clearer and more descriptive name.
+ * For backward compatibility, this type is still exported as `Props`, but it is recommended to migrate to using `ContentEditableProps` instead.
+ *
+ * This alias is maintained for compatibility purposes but may be removed in future versions.
+ * Please update your codebase to use `ContentEditableProps` to ensure long-term maintainability.
+ */
+export type Props = ContentEditableProps;
+export declare const ContentEditable: import("react").ForwardRefExoticComponent<ContentEditableProps & import("react").RefAttributes<HTMLDivElement>>;