@blocknote/core 0.1.0 → 0.1.1

package/src/shared/components/toolbar/ToolbarDropdownTarget.tsx

@@ -0,0 +1,31 @@
+import { Button } from "@mantine/core";
+import { HiChevronDown } from "react-icons/hi";
+import { IconType } from "react-icons";
+import { forwardRef } from "react";
+
+export type ToolbarDropdownTargetProps = {
+  text: string;
+  icon?: IconType;
+  isDisabled?: boolean;
+};
+
+export const ToolbarDropdownTarget = forwardRef<
+  HTMLButtonElement,
+  ToolbarDropdownTargetProps
+>((props: ToolbarDropdownTargetProps, ref) => {
+  const { text, icon, isDisabled, ...others } = props;
+
+  const TargetIcon = props.icon;
+  return (
+    <Button
+      leftIcon={TargetIcon && <TargetIcon size={16} />}
+      rightIcon={<HiChevronDown />}
+      size={"xs"}
+      variant={"subtle"}
+      disabled={props.isDisabled}
+      ref={ref}
+      {...others}>
+      {props.text}
+    </Button>
+  );
+});

package/src/shared/plugins/suggestion/SuggestionItem.ts

@@ -1,3 +1,5 @@
+import { IconType } from "react-icons";
+
 /**
  * A generic interface used in all suggestion menus (slash menu, mentions, etc)
  */
@@ -15,7 +17,7 @@ export default interface SuggestionItem {
   /**
    * The react icon
    */
-  icon?: React.ComponentType<{ className: string }>;
+  icon?: IconType;
 
   hint?: string;
 

package/src/shared/plugins/suggestion/{SuggestionListReactRenderer.ts → SuggestionListReactRenderer.tsx}

@@ -6,6 +6,8 @@ import {
   SuggestionList,
   SuggestionListProps,
 } from "./components/SuggestionList";
+import { BlockNoteTheme } from "../../../BlockNoteTheme";
+import { MantineProvider } from "@mantine/core";
 
 /**
  * The interface that each suggestion renderer should conform to.
@@ -140,10 +142,17 @@ export default function createRenderer<T extends SuggestionItem>(
         selectedIndex,
       };
 
-      component = new ReactRenderer(SuggestionList as any, {
-        editor: editor as ReactEditor,
-        props: componentProps,
-      });
+      component = new ReactRenderer(
+        (props: SuggestionListProps<T>) => (
+          <MantineProvider theme={BlockNoteTheme}>
+            <SuggestionList {...props} />
+          </MantineProvider>
+        ),
+        {
+          editor: editor as ReactEditor,
+          props: componentProps,
+        }
+      );
 
       popup = tippy("body", {
         getReferenceClientRect: newProps.clientRect,

package/src/shared/plugins/suggestion/components/SuggestionGroup.tsx

@@ -1,94 +1,6 @@
-import { ButtonItem, Section } from "@atlaskit/menu";
-import React from "react";
+import { Menu } from "@mantine/core";
 import SuggestionItem from "../SuggestionItem";
-import styles from "./SuggestionGroup.module.css";
-
-const MIN_LEFT_MARGIN = 5;
-
-function SuggestionContent<T extends SuggestionItem>(props: { item: T }) {
-  return (
-    <div className={styles.suggestionWrapper}>
-      <div>
-        <div className={styles.buttonName}>{props.item.name}</div>
-        {props.item.hint && (
-          <div className={styles.buttonHint}>{props.item.hint}</div>
-        )}
-      </div>
-      {props.item.shortcut && (
-        <div>
-          <div className={styles.buttonShortcut}>{props.item.shortcut}</div>
-        </div>
-      )}
-    </div>
-  );
-}
-
-function getIcon<T extends SuggestionItem>(
-  item: T,
-  isButtonSelected: boolean
-): JSX.Element | undefined {
-  const Icon = item.icon;
-  return (
-    Icon && (
-      <div className={styles.iconWrapper}>
-        <Icon
-          className={
-            styles.icon + " " + (isButtonSelected ? styles.selectedIcon : "")
-          }
-        />
-      </div>
-    )
-  );
-}
-
-type SuggestionComponentProps<T> = {
-  item: T;
-  index: number;
-  selectedIndex?: number;
-  clickItem: (item: T) => void;
-};
-
-function SuggestionComponent<T extends SuggestionItem>(
-  props: SuggestionComponentProps<T>
-) {
-  let isButtonSelected =
-    props.selectedIndex !== undefined && props.selectedIndex === props.index;
-
-  const buttonRef = React.useRef<HTMLElement>(null);
-  React.useEffect(() => {
-    if (
-      isButtonSelected &&
-      buttonRef.current &&
-      buttonRef.current.getBoundingClientRect().left > MIN_LEFT_MARGIN //TODO: Kinda hacky, fix
-      // This check is needed because initially the menu is initialized somewhere above outside the screen (with left = 1)
-      // scrollIntoView() is called before the menu is set in the right place, and without the check would scroll to the top of the page every time
-    ) {
-      buttonRef.current.scrollIntoView({
-        behavior: "smooth",
-        block: "nearest",
-      });
-    }
-  }, [isButtonSelected]);
-
-  return (
-    <div className={styles.buttonItem}>
-      <ButtonItem
-        isSelected={isButtonSelected} // This is needed to navigate with the keyboard
-        iconBefore={getIcon(props.item, isButtonSelected)}
-        onClick={(_e) => {
-          setTimeout(() => {
-            props.clickItem(props.item);
-          }, 0);
-
-          // e.stopPropagation();
-          // e.preventDefault();
-        }}
-        ref={buttonRef}>
-        <SuggestionContent item={props.item} />
-      </ButtonItem>
-    </div>
-  );
-}
+import { SuggestionGroupItem } from "./SuggestionGroupItem";
 
 type SuggestionGroupProps<T> = {
   /**
@@ -117,10 +29,11 @@ export function SuggestionGroup<T extends SuggestionItem>(
   props: SuggestionGroupProps<T>
 ) {
   return (
-    <Section title={props.name}>
+    <>
+      <Menu.Label>{props.name}</Menu.Label>
       {props.items.map((item, index) => {
         return (
-          <SuggestionComponent
+          <SuggestionGroupItem
             item={item}
             key={index} // TODO: using index as key is not ideal for performance, better have ids on suggestionItems
             index={index}
@@ -129,6 +42,6 @@ export function SuggestionGroup<T extends SuggestionItem>(
           />
         );
       })}
-    </Section>
+    </>
   );
 }

package/src/shared/plugins/suggestion/components/SuggestionGroupItem.tsx

@@ -0,0 +1,82 @@
+import SuggestionItem from "../SuggestionItem";
+import { useEffect, useRef } from "react";
+import { Badge, createStyles, Menu, Stack, Text } from "@mantine/core";
+
+const MIN_LEFT_MARGIN = 5;
+
+export type SuggestionGroupItemProps<T> = {
+  item: T;
+  index: number;
+  selectedIndex?: number;
+  clickItem: (item: T) => void;
+};
+
+export function SuggestionGroupItem<T extends SuggestionItem>(
+  props: SuggestionGroupItemProps<T>
+) {
+  const itemRef = useRef<HTMLButtonElement>(null);
+  const { classes } = createStyles({ root: {} })(undefined, {
+    name: "SuggestionListItem",
+  });
+
+  function isSelected() {
+    const isKeyboardSelected =
+      props.selectedIndex !== undefined && props.selectedIndex === props.index;
+    const isMouseSelected = itemRef.current?.matches(":hover");
+
+    return isKeyboardSelected || isMouseSelected;
+  }
+
+  // Updates HTML "data-hovered" attribute which Mantine uses to set mouse hover styles.
+  // Allows users to "hover" menu items when navigating using the keyboard.
+  function updateSelection() {
+    isSelected()
+      ? itemRef.current?.setAttribute("data-hovered", "true")
+      : itemRef.current?.removeAttribute("data-hovered");
+  }
+
+  useEffect(() => {
+    // Updates whether the item is selected with the keyboard (triggered on selectedIndex prop change).
+    updateSelection();
+
+    if (
+      isSelected() &&
+      itemRef.current &&
+      itemRef.current.getBoundingClientRect().left > MIN_LEFT_MARGIN //TODO: Kinda hacky, fix
+      // This check is needed because initially the menu is initialized somewhere above outside the screen (with left = 1)
+      // scrollIntoView() is called before the menu is set in the right place, and without the check would scroll to the top of the page every time
+    ) {
+      itemRef.current.scrollIntoView({
+        behavior: "smooth",
+        block: "nearest",
+      });
+    }
+  });
+
+  const Icon = props.item.icon;
+
+  return (
+    <Menu.Item
+      className={classes.root}
+      icon={Icon && <Icon size={18} />}
+      onClick={() => props.clickItem(props.item)}
+      // Ensures an item selected with both mouse & keyboard doesn't get deselected on mouse leave.
+      onMouseLeave={() => {
+        setTimeout(() => {
+          updateSelection();
+        });
+      }}
+      ref={itemRef}
+      rightSection={
+        props.item.shortcut && <Badge size={"xs"}>{props.item.shortcut}</Badge>
+      }>
+      <Stack>
+        {/*Might need separate classes.*/}
+        <Text size={14} weight={500}>
+          {props.item.name}
+        </Text>
+        <Text size={10}>{props.item.hint}</Text>
+      </Stack>
+    </Menu.Item>
+  );
+}

package/src/shared/plugins/suggestion/components/SuggestionList.tsx

@@ -1,39 +1,31 @@
-import { MenuGroup, Section } from "@atlaskit/menu";
-import styles from "./SuggestionList.module.css";
-import rootStyles from "../../../../root.module.css";
+import { createStyles, Menu } from "@mantine/core";
 import { SuggestionGroup } from "./SuggestionGroup";
 import SuggestionItem from "../SuggestionItem";
 
 export type SuggestionListProps<T> = {
-  /**
-   * Object containing all suggestion items, grouped by their `groupName`.
-   */
+  // Object containing all suggestion items, grouped by their `groupName`.
   groups: {
     [groupName: string]: T[];
   };
 
-  /**
-   * The total number of suggestion-items
-   */
+  //The total number of suggestion-items
   count: number;
 
-  /**
-   * This callback gets executed whenever an item is clicked on
-   */
+  // This callback gets executed whenever an item is clicked on
   onSelectItem: (item: T) => void;
 
-  /**
-   * The index of the item that is currently selected (but not yet clicked on)
-   */
+  // The index of the item that is currently selected (but not yet clicked on)
   selectedIndex: number;
 };
 
-/**
- * Stateless component that renders the suggestion list
- */
+// Stateless component that renders the suggestion list
 export function SuggestionList<T extends SuggestionItem>(
   props: SuggestionListProps<T>
 ) {
+  const { classes } = createStyles({ root: {} })(undefined, {
+    name: "SuggestionList",
+  });
+
   const renderedGroups = [];
 
   let currentGroupIndex = 0;
@@ -58,15 +50,24 @@ export function SuggestionList<T extends SuggestionItem>(
   }
 
   return (
-    <div className={styles.menuList + " " + rootStyles.bnRoot}>
-      <MenuGroup>
+    <Menu
+      /** Hacky fix to get the desired menu behaviour. The trigger="hover"
+       * attribute allows focus to remain on the editor, allowing for suggestion
+       * filtering. The closeDelay=10000000 attribute allows the menu to stay open
+       * practically indefinitely, as normally hovering off it would cause it to
+       * close due to trigger="hover".
+       */
+      defaultOpened={true}
+      trigger={"hover"}
+      closeDelay={10000000}>
+      <Menu.Dropdown className={classes.root}>
         {renderedGroups.length > 0 ? (
           renderedGroups
         ) : (
-          <Section title={"No match found"}> </Section>
+          <Menu.Item>No match found</Menu.Item>
         )}
-      </MenuGroup>
-    </div>
+      </Menu.Dropdown>
+    </Menu>
 
     // doesn't work well yet, maybe https://github.com/atomiks/tippyjs-react/issues/173
     // We now render the tippy element manually in SuggestionListReactRenderer

package/src/utils.ts

@@ -0,0 +1,12 @@
+export const isAppleOS = () =>
+  /Mac/.test(navigator.platform) ||
+  (/AppleWebKit/.test(navigator.userAgent) &&
+    /Mobile\/\w+/.test(navigator.userAgent));
+
+export function formatKeyboardShortcut(shortcut: string) {
+  if (isAppleOS()) {
+    return shortcut.replace("Mod", "⌘");
+  } else {
+    return shortcut.replace("Mod", "Ctrl");
+  }
+}

package/types/src/BlockNoteTheme.d.ts

@@ -0,0 +1,2 @@
+import { MantineThemeOverride } from "@mantine/core";
+export declare const BlockNoteTheme: MantineThemeOverride;

package/types/src/commands/indentation.d.ts

@@ -0,0 +1,2 @@
+import { LexicalEditor } from "lexical";
+export declare function registerIndentationCommands(editor: LexicalEditor): () => void;

package/types/src/extensions/Blocks/BlockAttributes.d.ts

@@ -0,0 +1,2 @@
+declare const BlockAttributes: Record<string, string>;
+export default BlockAttributes;

package/types/src/extensions/Blocks/MultipleNodeSelection.d.ts

@@ -0,0 +1,24 @@
+import { Selection } from "prosemirror-state";
+import { Node, ResolvedPos, Slice } from "prosemirror-model";
+import { Mappable } from "prosemirror-transform";
+/**
+ * This class represents an editor selection which spans multiple nodes/blocks. It's currently only used to allow users
+ * to drag multiple blocks at the same time. Expects the selection anchor and head to be between nodes, i.e. just before
+ * the first target node and just after the last, and that anchor and head are at the same nesting level.
+ *
+ * Partially based on ProseMirror's NodeSelection implementation:
+ * (https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.ts)
+ * MultipleNodeSelection differs from NodeSelection in the following ways:
+ * 1. Stores which nodes are included in the selection instead of just a single node.
+ * 2. Already expects the selection to start just before the first target node and ends just after the last, while a
+ * NodeSelection automatically sets both anchor and head to just before the single target node.
+ */
+export declare class MultipleNodeSelection extends Selection {
+    nodes: Array<Node>;
+    constructor($anchor: ResolvedPos, $head: ResolvedPos);
+    static create(doc: Node, from: number, to?: number): MultipleNodeSelection;
+    content(): Slice;
+    eq(selection: Selection): boolean;
+    map(doc: Node, mapping: Mappable): Selection;
+    toJSON(): any;
+}

package/types/src/extensions/Blocks/nodes/Block.d.ts

@@ -2,7 +2,7 @@ import { Node } from "@tiptap/core";
 export interface IBlock {
     HTMLAttributes: Record<string, any>;
 }
-export declare type Level = 1 | 2 | 3;
+export declare type Level = "1" | "2" | "3";
 export declare type ListType = "li" | "oli";
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {

package/types/src/extensions/BubbleMenu/component/LinkToolbarButton.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { Editor } from "@tiptap/core";
-import { SimpleToolbarButtonProps } from "../../../shared/components/toolbar/SimpleToolbarButton";
-declare type Props = SimpleToolbarButtonProps & {
+import { ToolbarButtonProps } from "../../../shared/components/toolbar/ToolbarButton";
+declare type Props = ToolbarButtonProps & {
     editor: Editor;
 };
 /**

package/types/src/extensions/Hyperlinks/menus/EditHyperlinkMenu.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+export declare type EditHyperlinkMenuProps = {
+    url: string;
+    text: string;
+    update: (url: string, text: string) => void;
+};
+/**
+ * Menu which opens when editing an existing hyperlink or creating a new one.
+ * Provides input fields for setting the hyperlink URL and title.
+ */
+export declare const EditHyperlinkMenu: (props: EditHyperlinkMenuProps) => JSX.Element;

package/types/src/extensions/Hyperlinks/menus/EditHyperlinkMenuItem.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { IconType } from "react-icons";
+export declare type EditHyperlinkMenuItemProps = {
+    icon: IconType;
+    mainIconTooltip: string;
+    secondaryIconTooltip?: string;
+    autofocus?: boolean;
+    placeholder?: string;
+    value?: string;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+};
+export declare function EditHyperlinkMenuItem(props: EditHyperlinkMenuItemProps): JSX.Element;

package/types/src/extensions/Hyperlinks/menus/EditHyperlinkMenuItemIcon.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { IconType } from "react-icons";
+export declare type EditHyperlinkMenuItemIconProps = {
+    icon: IconType;
+    mainTooltip: string;
+    secondaryTooltip?: string;
+};
+export declare function EditHyperlinkMenuItemIcon(props: EditHyperlinkMenuItemIconProps): JSX.Element;

package/types/src/extensions/Hyperlinks/menus/EditHyperlinkMenuItemInput.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export declare type EditHyperlinkMenuItemInputProps = {
+    autofocus?: boolean;
+    placeholder?: string;
+    value?: string;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+};
+export declare function EditHyperlinkMenuItemInput(props: EditHyperlinkMenuItemInputProps): JSX.Element;

package/types/src/extensions/Hyperlinks/menus/HoverHyperlinkMenu.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+declare type HoverHyperlinkMenuProps = {
+    url: string;
+    edit: () => void;
+    remove: () => void;
+};
+/**
+ * Menu which opens when hovering an existing hyperlink.
+ * Provides buttons for editing, opening, and removing the hyperlink.
+ */
+export declare const HoverHyperlinkMenu: (props: HoverHyperlinkMenuProps) => JSX.Element;
+export {};

package/types/src/extensions/Hyperlinks/menus/HyperlinkMenu.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+declare type HyperlinkMenuProps = {
+    url: string;
+    text: string;
+    pos: {
+        height: number;
+        width: number;
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    update: (url: string, text: string) => void;
+    remove: () => void;
+};
+/**
+ * Main menu component for the hyperlink extension.
+ * Either renders a menu to create/edit a hyperlink, or a menu to interact with it on mouse hover.
+ */
+export declare const HyperlinkMenu: (props: HyperlinkMenuProps) => JSX.Element;
+export {};

package/types/src/extensions/Hyperlinks/menus/helpers/PanelTextInput.d.ts

@@ -0,0 +1,39 @@
+import { KeyboardEvent, PureComponent } from "react";
+import { FocusEvent } from "react";
+export interface Props {
+    autoFocus?: boolean | FocusOptions;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    onCancel?: (e: KeyboardEvent) => void;
+    placeholder?: string;
+    onMouseDown?: Function;
+    onKeyDown?: (e: KeyboardEvent<any>) => void;
+    onUndo?: Function;
+    onRedo?: Function;
+    onBlur?: Function;
+    width?: number;
+    maxLength?: number;
+    testId?: string;
+    ariaLabel?: string;
+    id?: string;
+}
+export interface State {
+    value?: string;
+}
+export default class PanelTextInput extends PureComponent<Props, State> {
+    private input?;
+    private focusTimeoutId;
+    constructor(props: Props);
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    componentWillUnmount(): void;
+    onMouseDown: () => void;
+    onBlur: (e: FocusEvent<any>) => void;
+    render(): JSX.Element;
+    focus(): void;
+    private handleChange;
+    private handleKeydown;
+    private isUndoEvent;
+    private isRedoEvent;
+    private handleRef;
+}

package/types/src/extensions/Hyperlinks/menus/helpers/PanelTextInputStyles.d.ts

@@ -0,0 +1,3 @@
+export declare const N400 = "#505F79";
+export declare const N800 = "#172B4D";
+export declare const Input: import("styled-components").StyledComponent<"input", any, {}, never>;

package/types/src/extensions/Hyperlinks/menus/helpers/ToolbarComponent.d.ts

@@ -0,0 +1,13 @@
+export declare const N80 = "#97A0AF";
+export declare const N30 = "#EBECF0";
+export declare const RECENT_SEARCH_WIDTH_IN_PX = 420;
+export declare const RECENT_SEARCH_WIDTH_WITHOUT_ITEMS_IN_PX = 360;
+export declare const RECENT_SEARCH_HEIGHT_IN_PX = 360;
+export declare const InputWrapper = "\n  display: flex;\n  line-height: 0;\n  padding: 4px 0;\n  align-items: center;\n";
+export declare const UrlInputWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Container: import("styled-components").StyledComponent<"div", any, {
+    provider: boolean;
+}, never>;
+export declare const TextInputWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const IconWrapper: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const ContainerWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;

package/types/src/extensions/SlashMenu/SlashMenuItem.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="react" />
 import { Editor, Range } from "@tiptap/core";
 import SuggestionItem from "../../shared/plugins/suggestion/SuggestionItem";
+import { IconType } from "react-icons";
 export declare type SlashMenuCallback = (editor: Editor, range: Range) => boolean;
 export declare enum SlashMenuGroups {
     HEADINGS = "Headings",
@@ -20,9 +20,7 @@ export declare class SlashMenuItem implements SuggestionItem {
     readonly group: SlashMenuGroups;
     readonly execute: SlashMenuCallback;
     readonly aliases: string[];
-    readonly icon?: import("react").ComponentType<{
-        className: string;
-    }> | undefined;
+    readonly icon?: IconType | undefined;
     readonly hint?: string | undefined;
     readonly shortcut?: string | undefined;
     groupName: string;
@@ -34,10 +32,9 @@ export declare class SlashMenuItem implements SuggestionItem {
      * @param execute The callback for creating a new node
      * @param aliases Aliases for this command
      * @param icon To be shown next to the name in the menu
+     * @param hint Short description of command
      * @param shortcut Info about keyboard shortcut that would activate this command
      */
-    constructor(name: string, group: SlashMenuGroups, execute: SlashMenuCallback, aliases?: string[], icon?: import("react").ComponentType<{
-        className: string;
-    }> | undefined, hint?: string | undefined, shortcut?: string | undefined);
+    constructor(name: string, group: SlashMenuGroups, execute: SlashMenuCallback, aliases?: string[], icon?: IconType | undefined, hint?: string | undefined, shortcut?: string | undefined);
     match(query: string): boolean;
 }

package/types/src/nodes/ChildgroupNode.d.ts

@@ -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.
+ *
+ */
+import { EditorConfig, ElementNode, LexicalNode, NodeKey, RangeSelection, SerializedElementNode, Spread, TextNode } from "lexical";
+export declare type SerializedChildgroupNode = Spread<{
+    type: "childgroup";
+    version: 1;
+}, SerializedElementNode>;
+export declare class ChildgroupNode extends ElementNode {
+    static getType(): string;
+    static clone(node: ChildgroupNode): ChildgroupNode;
+    constructor(key?: NodeKey);
+    canBeEmpty(): boolean;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(_prevNode: TextNode, _dom: HTMLElement, _config: EditorConfig): boolean;
+    select(_anchorOffset?: number | undefined, _focusOffset?: number | undefined): RangeSelection;
+    selectStart(): RangeSelection;
+    insertBeforeDOM(dom: HTMLElement, childDOM: HTMLElement, referenceNode: Node | null): void;
+    static importJSON(_serializedNode: SerializedChildgroupNode): ChildgroupNode;
+    exportJSON(): SerializedChildgroupNode;
+    getClassName(): string;
+}
+export declare function $isChildgroupNode(node: LexicalNode | null | undefined): node is ChildgroupNode;
+export declare function $createChildgroupNode(): ChildgroupNode;

package/types/src/nodes/patchNodes.d.ts

@@ -0,0 +1 @@
+export declare function patchNode(node: any): void;

package/types/src/plugins/TreeViewPlugin/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function TreeViewPlugin(): JSX.Element;

package/types/src/plugins/animation.d.ts

@@ -0,0 +1,2 @@
+import { LexicalEditor } from "lexical";
+export declare function registerAnimation(editor: LexicalEditor): () => void;