zurfyx-lexical-react 0.39.1-nightly.20251225.0

package/flow/LexicalAutoEmbedPlugin.js.flow

@@ -0,0 +1,64 @@
+/**
+ * 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 {LexicalNode, MutationListener} from 'lexical';
+
+import {MenuOption} from '@lexical/react/LexicalTypeaheadMenuPlugin';
+import type {LexicalCommand, LexicalEditor, NodeKey, TextNode} from 'lexical';
+import * as React from 'react';
+import {createCommand} from 'lexical';
+import type {MenuRenderFn} from './LexicalTypeaheadMenuPlugin';
+
+export type EmbedMatchResult = {
+  url: string,
+  id: string,
+};
+
+export interface EmbedConfig {
+  // Used to identify this config e.g. youtube, tweet, google-maps.
+  type: string;
+  // Determine if a given URL is a match and return url data.
+  parseUrl: (text: string) => EmbedMatchResult | null;
+  // Create the Lexical embed node from the url data.
+  insertNode: (editor: LexicalEditor, result: EmbedMatchResult) => void;
+}
+
+export const URL_MATCHER: RegExp =
+  /((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/;
+
+export const INSERT_EMBED_COMMAND: LexicalCommand<EmbedConfig['type']> =
+  createCommand('INSERT_EMBED_COMMAND');
+
+type LexicalAutoEmbedPluginProps<TEmbedConfig> = {
+  embedConfigs: Array<TEmbedConfig>,
+  onOpenEmbedModalForConfig: (embedConfig: TEmbedConfig) => void,
+  getMenuOptions: (
+    activeEmbedConfig: TEmbedConfig,
+    embedFn: () => void,
+    dismissFn: () => void,
+  ) => Array<AutoEmbedOption>,
+  menuRenderFn: MenuRenderFn<AutoEmbedOption>,
+};
+
+declare export class AutoEmbedOption extends MenuOption {
+  title: string;
+  icon: React.MixedElement;
+  onSelect: (targetNode: LexicalNode | null) => void;
+  constructor(
+    title: string,
+    options: {
+      icon: React.MixedElement,
+      onSelect: (targetNode: LexicalNode | null) => void,
+    },
+  ): void;
+}
+
+declare export function LexicalAutoEmbedPlugin<TEmbedConfig>(
+  LexicalAutoEmbedPluginProps<TEmbedConfig>,
+): React.MixedElement | null;

package/flow/LexicalAutoFocusPlugin.js.flow

@@ -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.
+ *
+ * @flow strict
+ */
+
+type Props = $ReadOnly<{
+  defaultSelection?: 'rootStart' | 'rootEnd',
+}>;
+
+declare export function AutoFocusPlugin(props: Props): null;

package/flow/LexicalAutoLinkPlugin.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 {LinkAttributes, ChangeHandler, LinkMatcher} from '@lexical/link';
+import {createLinkMatcherWithRegExp} from '@lexical/link';
+export {createLinkMatcherWithRegExp};
+export type {ChangeHandler, LinkMatcher};
+
+declare export function AutoLinkPlugin(props: {
+  matchers: Array<LinkMatcher>,
+  onChange?: ChangeHandler,
+}): React.Node;

package/flow/LexicalBlockWithAlignableContents.js.flow

@@ -0,0 +1,28 @@
+/**
+ * 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 {
+  ElementFormatType,
+  LexicalEditor,
+  EditorThemeClasses,
+  LexicalNode,
+  NodeKey,
+} from 'lexical';
+
+type Props = $ReadOnly<{
+  children: React.Node,
+  format: ?ElementFormatType,
+  nodeKey: NodeKey,
+  className: $ReadOnly<{
+    base: string,
+    focus: string,
+  }>,
+}>;
+
+declare export function BlockWithAlignableContents(Props): React.Node;

package/flow/LexicalCharacterLimitPlugin.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
+ */
+
+declare export function CharacterLimitPlugin(props: {
+  charset: 'UTF-8' | 'UTF-16',
+}): React.Node;

package/flow/LexicalCheckListPlugin.js.flow

@@ -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.
+ *
+ * @flow strict
+ */
+
+declare export function CheckListPlugin(): null;

package/flow/LexicalClearEditorPlugin.js.flow

@@ -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.
+ *
+ * @flow strict
+ */
+
+type Props = $ReadOnly<{
+  onClear?: () => void,
+}>;
+
+declare export function ClearEditorPlugin(Props): React.Node;

package/flow/LexicalClickableLinkPlugin.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
+ */
+
+declare export function ClickableLinkPlugin({
+  newTab?: boolean,
+}): null;

package/flow/LexicalCollaborationContext.js.flow

@@ -0,0 +1,22 @@
+/**
+ * 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 {Doc} from 'yjs';
+
+type CollaborationContextType = {
+  clientID: number,
+  color: string,
+  isCollabActive: boolean,
+  name: string,
+  yjsDocMap: Map<string, Doc>,
+};
+
+declare export var CollaborationContext: React.Context<CollaborationContextType>;
+declare export function useCollaborationContext(): CollaborationContextType;
+declare export function LexicalCollaboration({children: React.Node}): React.Node;

package/flow/LexicalCollaborationPlugin.js.flow

@@ -0,0 +1,50 @@
+/**
+ * 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 {InitialEditorStateType} from '@lexical/react/LexicalComposer';
+import type {ExcludedProperties, ProviderAwareness} from '@lexical/yjs';
+import type {Doc, RelativePosition} from 'yjs';
+
+export interface Provider {
+  connect(): void | Promise<void>;
+  disconnect(): void;
+  awareness: ProviderAwareness;
+  on(type: 'sync', cb: (isSynced: boolean) => void): void;
+  on(type: 'status', cb: ({status: string}) => void): void;
+  // $FlowFixMe[unclear-type]: temp
+  on(type: 'update', cb: (any) => void): void;
+  on(type: 'reload', cb: (doc: Doc) => void): void;
+  off(type: 'sync', cb: (isSynced: boolean) => void): void;
+  // $FlowFixMe[unclear-type]: temp
+  off(type: 'update', cb: (any) => void): void;
+  off(type: 'status', cb: ({status: string}) => void): void;
+  off(type: 'reload', cb: (doc: Doc) => void): void;
+}
+
+export type ProviderFactory = (
+  id: string,
+  yjsDocMap: Map<string, Doc>,
+) => Provider;
+
+export type CursorsContainerRef = {current: null | HTMLElement};
+
+declare export function CollaborationPlugin(arg0: {
+  id: string,
+  providerFactory: (
+    // eslint-disable-next-line no-shadow
+    id: string,
+    yjsDocMap: Map<string, Doc>,
+  ) => Provider,
+  shouldBootstrap: boolean,
+  username?: string,
+  cursorColor?: string,
+  cursorsContainerRef?: CursorsContainerRef,
+  initialEditorState?: InitialEditorStateType,
+  excludedProperties?: ExcludedProperties,
+}): React.Node;

package/flow/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/flow/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/flow/LexicalContentEditable.js.flow

@@ -0,0 +1,80 @@
+/**
+ * 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';
+// $FlowFixMe[cannot-resolve-module] - Not able to type this with a flow extension
+import type {TRefFor} from 'CoreTypes.flow';
+
+import * as React from 'react';
+
+type InlineStyle = {
+  [key: string]: mixed,
+};
+
+// Due to Flow limitations, we prefer fixed types over the built-in inexact HTMLElement
+type HTMLDivElementDOMProps = $ReadOnly<{
+  'aria-label'?: void | string,
+  'aria-labeledby'?: void | string,
+  'aria-activedescendant'?: void | string,
+  'aria-autocomplete'?: void | string,
+  'aria-describedby'?: void | string,
+  'aria-errormessage'?: void | string,
+  'aria-invalid'?: void | boolean,
+  'aria-owns'?: void | string,
+  'title'?: void | string,
+  onClick?: void | ((e: SyntheticEvent<HTMLDivElement>) => mixed),
+  autoCapitalize?: void | boolean,
+  autoComplete?: void | boolean,
+  autoCorrect?: void | boolean,
+  id?: void | string,
+  className?: void | string,
+  'data-testid'?: void | string,
+  role?: void | string,
+  spellCheck?: void | boolean,
+  suppressContentEditableWarning?: void | boolean,
+  tabIndex?: void | number,
+  style?: void | InlineStyle | CSSStyleDeclaration,
+  'data-testid'?: void | string,
+}>;
+
+export type PlaceholderProps =
+  | $ReadOnly<{
+      'aria-placeholder'?: void,
+      placeholder?: null,
+    }>
+  | $ReadOnly<{
+      'aria-placeholder': string,
+      placeholder:
+        | ((isEditable: boolean) => null | React.Node)
+        | null
+        | React.Node,
+    }>;
+
+export type Props = $ReadOnly<{
+  ...HTMLDivElementDOMProps,
+  ariaActiveDescendant?: string,
+  ariaAutoComplete?: string,
+  ariaControls?: string,
+  ariaDescribedBy?: string,
+  ariaErrorMessage?: string,
+  ariaExpanded?: boolean,
+  ariaInvalid?: boolean,
+  ariaLabel?: string,
+  ariaLabelledBy?: string,
+  ariaMultiline?: boolean,
+  ariaOwns?: string,
+  ariaRequired?: string,
+  autoCapitalize?: boolean,
+  ...PlaceholderProps,
+}>;
+
+declare export var ContentEditable: component(
+  ref?: React.RefSetter<HTMLDivElement>,
+  ...Props
+);

package/flow/LexicalContextMenuPlugin.js.flow

@@ -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.
+ *
+ * @flow strict
+ */
+
+/** 
+ * @deprecated use LexicalNodeContextMenuPlugin instead
+ * LexicalContextMenuPlugin
+ */

package/flow/LexicalDecoratorBlockNode.js.flow

@@ -0,0 +1,35 @@
+/**
+ * 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 {
+  ElementFormatType,
+  LexicalNode,
+  LexicalCommand,
+  NodeKey,
+  SerializedDecoratorNode
+} from 'lexical';
+
+import {DecoratorNode} from 'lexical';
+
+declare export class DecoratorBlockNode<T> extends DecoratorNode<T> {
+  __format: ?ElementFormatType;
+  constructor(format?: ?ElementFormatType, key?: NodeKey): void;
+  createDOM(): HTMLElement;
+  setFormat(format: ElementFormatType): void;
+}
+
+declare export function $isDecoratorBlockNode(
+  node: ?LexicalNode,
+): node is DecoratorBlockNode<{...}>;
+
+export type SerializedDecoratorBlockNode = {
+  ...SerializedDecoratorNode, 
+  format: ElementFormatType,
+  ...
+};

package/flow/LexicalDraggableBlockPlugin.js.flow

@@ -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.
+ *
+ * @flow strict
+ */
+
+import * as React from 'react';
+
+type Props = $ReadOnly<{
+  anchorElem?: ?HTMLElement,
+  menuRef: React.RefObject<?HTMLElement>,
+  targetLineRef: React.RefObject<?HTMLElement>,
+  menuComponent: React.Node,
+  targetLineComponent: React.Node,
+  isOnMenu: (element: HTMLElement) => boolean,
+  onElementChanged?: (element: HTMLElement | null) => void
+}>;
+	
+declare export function DraggableBlockPlugin_EXPERIMENTAL(
+  props: Props,
+): React.MixedElement;

package/flow/LexicalEditorRefPlugin.js.flow

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+import type {LexicalEditor} from 'lexical';
+// $FlowFixMe[cannot-resolve-module] - Not able to type this with a flow extension
+import type {TRefFor} from 'CoreTypes.flow';
+
+
+type Props = $ReadOnly<{
+  editorRef: TRefFor<LexicalEditor>,
+}>;
+
+declare export function EditorRefPlugin(props: Props): null;

package/flow/LexicalErrorBoundary.js.flow

@@ -0,0 +1,17 @@
+/**
+ * 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
+ */
+
+export type LexicalErrorBoundaryProps = $ReadOnly<{
+  children: React.Node,
+  onError: (error: Error) => void,
+}>;
+
+declare export function LexicalErrorBoundary(
+  props: LexicalErrorBoundaryProps,
+): React.Node;

package/flow/LexicalExtensionComponent.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
+ */
+
+/**
+ * LexicalExtensionComponent
+ */

package/flow/LexicalExtensionComposer.js.flow

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+
+/**
+ * LexicalExtensionComposer
+ */
+import type {AnyLexicalExtensionArgument} from 'lexical';
+import type {ReactConfig} from '@lexical/react/ReactExtension';
+export type LexicalExtensionComposerProps = {
+  extension: AnyLexicalExtensionArgument;
+  children: React.Node;
+  contentEditable?: ReactConfig['contentEditable'];
+}
+declare export function LexicalExtensionComposer(props: LexicalExtensionComposerProps): React.Node;

package/flow/LexicalHashtagPlugin.js.flow

@@ -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.
+ *
+ * @flow strict
+ */
+
+declare export function HashtagPlugin(): React.Node;

package/flow/LexicalHistoryPlugin.js.flow

@@ -0,0 +1,28 @@
+/**
+ * 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 {BaseSelection, EditorState, LexicalEditor} from 'lexical';
+
+export type HistoryStateEntry = {
+  editor: LexicalEditor,
+  editorState: EditorState,
+  undoSelection?: BaseSelection | null,
+};
+
+export type HistoryState = {
+  current: null | HistoryStateEntry,
+  redoStack: Array<HistoryStateEntry>,
+  undoStack: Array<HistoryStateEntry>,
+};
+
+declare export function HistoryPlugin({
+  externalHistoryState?: HistoryState,
+}): React.Node;
+
+declare export function createEmptyHistoryState(): HistoryState;

package/flow/LexicalHorizontalRuleNode.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 {LexicalNode, LexicalCommand, SerializedLexicalNode} from 'lexical';
+import {DecoratorNode} from 'lexical';
+export type SerializedHorizontalRuleNode = SerializedLexicalNode;
+declare export class HorizontalRuleNode extends DecoratorNode<React.Node> {
+  static getType(): string;
+  static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+  createDOM(): HTMLElement;
+  getTextContent(): '\n';
+  updateDOM(): false;
+  decorate(): React.Node;
+}
+
+declare export function $createHorizontalRuleNode(): HorizontalRuleNode;
+declare export function $isHorizontalRuleNode(
+  node: ?LexicalNode,
+): node is HorizontalRuleNode;
+
+declare export var INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;

package/flow/LexicalHorizontalRulePlugin.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
+ */
+
+type Props = $ReadOnly<{}>;
+
+declare export function HorizontalRulePlugin(props: Props): null;

package/flow/LexicalLinkPlugin.js.flow

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+type LinkAttributes = {
+  rel?: null | string;
+  target?: null | string;
+  title?: null | string;
+};
+
+type Props = $ReadOnly<{
+  validateUrl?: (url: string) => boolean,
+  attributes?: LinkAttributes,
+}>;
+
+declare export function LinkPlugin(props: Props): null;

package/flow/LexicalListPlugin.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
+ */
+
+declare export function ListPlugin(): null;
+
+export type ListPluginProps = {
+  hasStrictIndent?: boolean;
+};
+declare export function ListPlugin(props: ListPluginProps): null;