JSPM

mui-tiptap: A customizable Material UI styled WYSIWYG rich text editor, using Tiptap.

• ✨ Styled based on your own MUI theme (colors, fonts, light vs dark mode, etc.)
• 🛠️ Built on powerful Tiptap and ProseMirror foundations (extensible, real-time collaborative editing, cross-platform support, etc.)

Features:

• 🧰 An all-in-one RichTextEditor component to get started immediately (no other components or hooks needed!), or individual modular components to customize to your needs
• 😎 Built-in styles for Tiptap’s extensions (text formatting, lists, tables, Google Docs-like collaboration cursors; you name it!)
• ▶️ Composable and extendable menu buttons and controls for the standard Tiptap extensions
• 🖼️ ResizableImage extension for adding and resizing images directly in the editor
• ⚓ HeadingWithAnchor extension for dynamic GitHub-like anchor links for every heading you add
• 🔗 LinkBubbleMenu so adding and editing links is a breeze
• 🔢 FontSize extension for controlling text sizes
• 🔳 TableImproved extension that fixes problems in the underlying Tiptap Table extension
• 📝 TableBubbleMenu for interactively editing your rich text tables
• 💬 General-purpose ControlledBubbleMenu for building your own custom menus, solving some shortcomings of the Tiptap BubbleMenu
• And more!

Demo

Try it yourself in this CodeSandbox live demo!

Installation

npm install mui-tiptap

or

yarn add mui-tiptap

There are peer dependencies on @mui/material and @mui/icons-material (and their @emotion/ peers), and @tiptap/ packages. These should be installed automatically by default if you’re using npm 7+ or pnpm. Otherwise, if your project doesn’t already use those, you can install them with:

npm install @mui/material @mui/icons-material @emotion/react @emotion/styled @tiptap/react @tiptap/extension-heading @tiptap/extension-image @tiptap/extension-table @tiptap/pm @tiptap/core

or

yarn add @mui/material @mui/icons-material @emotion/react @emotion/styled @tiptap/react @tiptap/extension-heading @tiptap/extension-image @tiptap/extension-table @tiptap/pm @tiptap/core

Get started

Use the all-in-one component

The simplest way to render a rich text editor is to use the RichTextEditor component:

import Button from "@mui/material/Button";
import StarterKit from "@tiptap/starter-kit";
import {
  MenuButtonBold,
  MenuButtonItalic,
  MenuControlsContainer,
  MenuDivider,
  MenuSelectHeading,
  RichTextEditor,
  type RichTextEditorRef,
} from "mui-tiptap";
import { useRef } from "react";

function App() {
  const rteRef = useRef<RichTextEditorRef>(null);

  return (
    <div>
      <RichTextEditor
        ref={rteRef}
        extensions={[StarterKit]} // Or any Tiptap extensions you wish!
        content="<p>Hello world</p>" // Initial content for the editor
        // Optionally include `renderControls` for a menu-bar atop the editor:
        renderControls={() => (
          <MenuControlsContainer>
            <MenuSelectHeading />
            <MenuDivider />
            <MenuButtonBold />
            <MenuButtonItalic />
            {/* Add more controls of your choosing here */}
          </MenuControlsContainer>
        )}
      />

      <Button onClick={() => console.log(rteRef.current?.editor?.getHTML())}>
        Log HTML
      </Button>
    </div>
  );
}

Check out mui-tiptap extensions and components below to learn about extra Tiptap extensions and components (like more to include in renderControls) that you can use. See src/demo/Editor.tsx for a more thorough example of using RichTextEditor.

Create and provide the editor yourself

If you need more customization, you can instead define your editor using Tiptap’s useEditor hook, and lay out your UI using a selection of mui-tiptap components (and/or your own components).

Pass the editor to mui-tiptap’s RichTextEditorProvider component at the top of your component tree. From there, render whatever children within the provider that fit your needs.

The easiest is option is the RichTextField component, which is what RichTextEditor uses under the hood:

import { useEditor } from "@tiptap/react";
import StarterKit from "@tiptap/starter-kit";
import {
  MenuButtonBold,
  MenuButtonItalic,
  MenuControlsContainer,
  MenuDivider,
  MenuSelectHeading,
  RichTextEditorProvider,
  RichTextField,
} from "mui-tiptap";

function App() {
  const editor = useEditor({
    extensions: [StarterKit],
    content: "<p>Hello <b>world</b>!</p>",
  });
  return (
    <RichTextEditorProvider editor={editor}>
      <RichTextField
        controls={
          <MenuControlsContainer>
            <MenuSelectHeading />
            <MenuDivider />
            <MenuButtonBold />
            <MenuButtonItalic />
            {/* Add more controls of your choosing here */}
          </MenuControlsContainer>
        }
      />
    </RichTextEditorProvider>
  );
}

Or if you want full control over the UI, instead of RichTextField, you can build the editor area yourself and then just use the <RichTextContent /> component where you want the (styled) editable rich text content to appear. RichTextContent is the MUI-themed version of Tiptap's EditorContent component.

Render read-only rich text content

Use the RichTextReadOnly component and just pass in your HTML or ProseMirror JSON and your configured Tiptap extensions, like:

<RichTextReadOnly content="<p>Hello world</p>" extensions={[StarterKit]} />

Alternatively, you can set the RichTextEditor editable prop (or useEditor editable option) to false for a more configurable read-only option. Use RichTextReadOnly when:

• You just want to efficiently render editor HTML/JSON content directly, without any outlined field styling, controls setup, extra listener logic, access to the editor object, etc. (This component also skips creating the Tiptap editor if content is empty, which can help performance.)
• You want a convenient way to render content that updates as the content prop changes. (RichTextEditor by contrast does not re-render automatically on content changes, as described below.)

mui-tiptap extensions and components

Tiptap extensions

HeadingWithAnchor

A modified version of Tiptap’s Heading extension, with dynamic GitHub-like anchor links for every heading you add. An anchor link button will appear to the left of a heading when hovering over it, when the editor has editable set to false. This allows users to share links and jump to specific headings within your rendered editor content.

FontSize

Sets text font size. This extension requires the @tiptap/extension-text-style package to be installed and its TextStyle mark to be included in your extensions.

Can be controlled with the MenuSelectFontSize component.

Commands

• setFontSize(): Set the text font size (using a valid CSS font-size property). ex: "12px", "2em", "small"
• unsetFontSize(): Remove any previously set font size, reverting to the default size for the given mark.

LinkBubbleMenuHandler

To be used in conjunction with the LinkBubbleMenu component, as this extension provides editor commands to control the state of the link bubble menu.

Commands

• openLinkBubbleMenu(): Open/show the link bubble menu. Create a link if one doesn't exist at the current cursor selection, or edit the existing link if there is already a link at the current selection.
• editLinkInBubbleMenu(): Edit an existing link in the bubble menu, to be used when currently viewing a link in the already-opened bubble menu.
• closeLinkBubbleMenu(): Close/hide the link bubble menu, canceling any ongoing edits.

ResizableImage

A modified version of Tiptap’s Image extension, which adds the ability to resize images directly in the editor. A drag handle appears in the bottom right when clicking on an image, so users can interactively change the size.

TableImproved

A modified version of Tiptap’s Table extension that fixes problems related to column-resizing and editable state.

Namely, this version of the extension, coupled with the mui-tiptap CSS styles ensures that:

1. Columns respect their resized widths even when the editor has editable=false
2. Column resizing is possible regardless of initial editor state, when toggling from editable=false to editable=true

(Resolves these reported Tiptap issues: 1, 2, 3.)

Components

Controls components

These controls components help you quickly put together your menu bar, for each of the various Tiptap extensions you may want to use.

You can override all props for these components (e.g. to change the IconComponent, tooltipLabel, tooltipShortcutKeys for which shortcut is shown, onClick behavior, etc.). Or easily create controls for your own extensions and use-cases with the base MenuButton and MenuSelect components.

Other controls components:

• MenuButtonColorPicker: a button which can be used to bring up a mui-tiptap ColorPicker, letting the user select a color. Used by MenuButtonTextColor and MenuButtonHighlightColor, the props of which extend MenuButtonColorPicker. Important props:
  • swatchColors: Array of color options to show as "preset" color buttons.
  • value/onChange: Current color (CSS string) and its change callback. This is a controlled component, so these props must be provided, unless you're using MenuButtonTextColor or MenuButtonHighlightColor, which handle that logic.
  • popperId: Unique HTML ID for the color picker popper that will be shown when clicking this button (used for aria-describedby for accessibility).
  • PopperProps: Override the props for the popper that houses the color picker.
  • ColorPickerProps: Override the props for mui-tiptap ColorPicker, such as colorToHex to customize the color-parsing logic.
• MenuButtonRemoveFormatting: a control button that removes all inline formatting of marks (calling Tiptap’s unsetAllMarks())
• MenuDivider: renders a vertical line divider to separate different sections of your menu bar and implicitly group separate controls.
• MenuControlsContainer: provides consistent spacing between different editor controls components provided as children.

Typically you will define your controls (for RichTextEditor’s renderControls or RichTextField’s controls) like:

<MenuControlsContainer>
  <MenuSelectHeading />
  <MenuDivider />
  <MenuButtonBold />
  <MenuButtonItalic />
  {/* Add more controls of your choosing here */}
</MenuControlsContainer>

Style customization

You can override styles in several different ways, following standard MUI conventions. Most notably:

1. Use the sx prop with any mui-tiptap component. Example:

   <RichTextEditor {...otherProps} sx={{ backgroundColor: "#222" }} />

2. Use class names when rendering a mui-tiptap component, with the className and/or classes props. className applies a class to the root of the component, and classes allows for passing class names for various slots and states of the component.

   For example, if you have CSS specified externally like

   .custom-border {
     border-color: #222;
   }
   .custom-content {
     background-color: #eee;
   }

   you can apply it when rendering a component, such as:

   <MenuBar className="custom-border" />

   or

   <MenuBar classes={{ root: "custom-border", content: "custom-content" }} />

3. Use theme overrides (https://mui.com/material-ui/customization/theme-components/). Example:

   const theme = createTheme({
     components: {
       // Override the behavior for the mui-tiptap `FieldContainer`
       "MuiTiptap-FieldContainer": {
         defaultProps: {
           // If no `variant` value is set, use "standard"
           variant: "standard",
         },
         styleOverrides: {
           // Apply this background color to the `root` slot
           root: { backgroundColor: "#222" },
           // Apply this border style to the `notchedOutline` slot
           notchedOutline: { borderStyle: "dashed" },
         },
         variants: [
           // When the `disabled` prop is `true`, show a red outline
           {
             props: { disabled: true },
             style: { outline: "1px solid red" },
           },
         ],
       },
     },
   });

4. Apply styles based on utility class names of mui-tiptap components. These are useful for applying CSS externally, or for nested component styling when using sx or styleOverrides.

   For instance, for the RichTextField component, the "MuiTiptap-RichTextField-root" class name is applied to its root element, a separate class will be included on that element based on the current variant (like "MuiTiptap-RichTextField-outlined"), and its inner content element gets the "MuiTiptap-RichTextField-content" class.

   You can import helper objects from mui-tiptap to avoid hard-coding these, like import { richTextFieldClasses } from "mui-tiptap";, and access them like richTextFieldClasses.content for the "MuiTiptap-RichTextField-content" value.

Localization

All of the menu buttons, select components, and bubble menus allow you to override their default labels and content via props. Examples below.

<MenuButtonBold tooltipLabel="Toggle bold" />

<MenuButtonTextColor
  tooltipLabel="Text color"
  labels={{
    cancelButton: "Cancel",
    removeColorButton: "Reset",
    removeColorButtonTooltipTitle: "Remove the color",
    saveButton: "OK",
    textFieldPlaceholder: 'Ex: "#7cb5ec"',
  }}
/>

<MenuSelectFontFamily
  options={[
    { label: "Monospace", value: "monospace" },
    { label: "Serif", value: "serif" },
  ]}
  aria-label="Font families"
  emptyLabel="Font family"
  tooltipTitle="Change font family"
  unsetOptionLabel="Reset"
/>

<MenuSelectFontSize
  aria-label="Font sizes"
  tooltipTitle="Change font size"
  unsetOptionLabel="Reset"
/>

<MenuSelectHeading
  aria-label="Heading types"
  tooltipTitle="Change heading type"
  labels={{
    empty: "Change to…",
    paragraph: "Normal text",
    heading1: "H1",
    heading2: "H2",
    heading3: "H3",
    heading4: "H4",
    heading5: "H5",
    heading6: "H6",
  }}
/>

<MenuSelectTextAlign
  aria-label="Text alignments"
  tooltipTitle="Change text alignment"
  options={[
    {
      value: "left",
      label: "Text-align left",
      shortcutKeys: ["mod", "Shift", "L"],
      IconComponent: MyCustomLeftAlignIcon,
    },
    {
      value: "right",
      label: "Text-align right",
      shortcutKeys: ["mod", "Shift", "R"],
      IconComponent: MyCustomRightAlignIcon,
    },
  ]}
/>

<LinkBubbleMenu
  labels={{
    viewLinkEditButtonLabel: "Edit link",
    viewLinkRemoveButtonLabel: "Remove link",
    editLinkAddTitle: "Add new link",
    editLinkEditTitle: "Update this link",
    editLinkCancelButtonLabel: "Cancel changes",
    editLinkTextInputLabel: "Text content",
    editLinkHrefInputLabel: "URL",
    editLinkSaveButtonLabel: "Save changes",
  }}
/>

<TableBubbleMenu
  labels={{
    insertColumnBefore: "Add a new column before this",
    insertColumnAfter: "Add a new column after this",
    deleteColumn: "Remove current column",
    // And several more. Check props type definition for details!
  }}
/>

Tips and suggestions

Choosing your editor extensions

Browse the official Tiptap extensions, and check out mui-tiptap’s additional extensions. The easiest way to get started is to install and use Tiptap’s StarterKit extension, which bundles several common Tiptap extensions.

To use an extension, you need to (1) install its package and (2) include the extension in the extensions array when instantiating your editor (either with <RichTextEditor extensions={[]} /> or useEditor({ extensions: [] })).

Extension precedence and ordering

Extensions that need to be higher precedence (for their keyboard shortcuts, etc.) should come later in your extensions array. (See Tiptap's general notes on extension plugin precedence and ordering here.) For example:

• Put the TableImproved (or Table) extension first in the array.
  • As noted in the underlying prosemirror-tables package, the table editing plugin should have the lowest precedence, since it depends on key and mouse events but other plugins will likely need to handle those first. For instance, if you want to indent or dedent a list item inside a table, you should be able to do that by pressing tab, and tab should only move between table cells if not within such a nested node.
• Put the Blockquote extension after the Bold extension, so Blockquote’s keyboard shortcut takes precedence.
  • Otherwise, the keyboard shortcut for Blockquote (Cmd+Shift+B) will mistakenly toggle the bold mark (due to its “overlapping” Cmd+b shortcut). (See related Tiptap issues here and here.)
• Put the Mention extension after list-related extensions (TaskList, TaskItem, BulletList, OrderedList, ListItem, etc.) so that pressing "Enter" on a mention suggestion will select it, rather than create a new list item (when trying to @mention something within an existing list item).

Other extension tips

• If you’d like Subscript and Superscript extensions to be mutually exclusive, so that text can't be both superscript and subscript simultaneously, use the excludes configuration parameter to exclude each other.

  • As described in this Tiptap issue. For instance:

    const CustomSubscript = Subscript.extend({
      excludes: "superscript",
    });
    const CustomSuperscript = Superscript.extend({
      excludes: "subscript",
    });

• If you’d prefer to be able to style your inline Code marks (e.g., make them bold, add links, change font size), you should extend the extension and override the excludes field, since by default it uses "_" to make it mutually exclusive from all other marks. For instance, to allow you to apply Code with any other inline mark, use excludes: "", or to make it work with all except italics, use:

  Code.extend({ excludes: "italic" });

Drag-and-drop and paste for images

You can provide editorProps to the RichTextEditor component or useEditor, and provide the handleDrop and handlePaste options to add support for drag-and-drop and paste of image files, respectively. Check out the mui-tiptap example of this in action. The mui-tiptap insertImages util is handy for this to take uploaded files and insert them into the editor content.

Re-rendering RichTextEditor when content changes

By default, RichTextEditor uses content the same way that Tiptap’s useEditor does: it sets the initial content for the editor, and subsequent changes to the content variable will not change what content is rendered. (Only the user’s editor interaction will.) This can avoid annoyances like overwriting the content while a user is actively typing or editing.

It is not efficient to use RichTextEditor/useEditor as a fully “controlled” component where you change content on each call to the editor’s onUpdate, due to the fact that editor content must be serialized to get the HTML string (getHTML()) or ProseMirror JSON (getJSON()) (see Tiptap docs and this discussion).

But if you need this behavior in certain situations, like you have changed the content external to the component and separate from the user’s editor interaction, you can call editor.commands.setContent(content) (docs) within a hook to update the editor document.

For instance, you could use something like the following, which (1) only calls setContent when the editor is either read-only or unfocused (aiming to avoid losing any in-progress changes the user is making, though keep in mind that changes to isFocused itself do not cause re-rendering and so won't re-run the effect), and (2) tries to preserve the user’s current selection/caret:

const editor = rteRef.current?.editor;
useEffect(() => {
  if (!editor || editor.isDestroyed) {
    return;
  }
  if (!editor.isFocused || !editor.isEditable) {
    // Use queueMicrotask per https://github.com/ueberdosis/tiptap/issues/3764#issuecomment-1546854730
    queueMicrotask(() => {
      const currentSelection = editor.state.selection;
      editor
        .chain()
        .setContent(content)
        .setTextSelection(currentSelection)
        .run();
    });
  }
}, [content, editor, editor?.isEditable, editor?.isFocused]);

You could also alternatively pass content as an editor dependency via <RichTextEditor … editorDependencies={[content]} /> (or equivalently include it in your useEditor dependency array), and this will force-recreate the entire editor upon changes to the value. This is a much less efficient option, and it can cause a visual “flash” as the editor is rebuilt.

Note that if these content updates are coming from changes other users are making (e.g. saved to a database), it may be better to use collaborative editing functionality with Yjs, and not rely on content at all.

Contributing

Get started here.