@dxos/plugin-markdown 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/components/MarkdownEditor/MarkdownEditor.tsx

@@ -4,32 +4,34 @@
 
 import { type Extension } from '@codemirror/state';
 import { type EditorView } from '@codemirror/view';
+import { type Atom } from '@effect-atom/atom-react';
 import { createContext } from '@radix-ui/react-context';
-import React, { type PropsWithChildren, useMemo, useState } from 'react';
+import React, { type ReactNode, useCallback, useMemo, useState } from 'react';
 import { createPortal } from 'react-dom';
 
-import { Surface } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
 import { DXN } from '@dxos/keys';
-import { type Live } from '@dxos/live-object';
 import { useClient } from '@dxos/react-client';
+import { type ThemedClassName } from '@dxos/react-ui';
 import {
+  type EditorRootProps,
   type EditorToolbarState,
-  PopoverMenuProvider,
-  type PreviewBlock,
-  type PreviewOptions,
-  type UsePopoverMenu,
-  useEditorToolbarState,
-  usePopoverMenu,
+  createEditorController,
+  useEditorContext,
 } from '@dxos/react-ui-editor';
+import { type PreviewBlock, type PreviewOptions } from '@dxos/ui-editor';
+import { composable, composableProps } from '@dxos/ui-theme';
 import { isNonNullable } from '@dxos/util';
 
 import {
   type DocumentType,
   type ExtensionsOptions,
-  type UsePopoverMenuOptionsProps,
+  type UseEditorMenuOptionsProps,
+  useEditorMenuOptions,
   useExtensions,
-  usePopoverMenuOptions,
-} from '../../hooks';
+} from '#hooks';
 
 import {
   MarkdownEditorContent as NaturalMarkdownEditorContent,
@@ -46,198 +48,239 @@ import {
 
 type MarkdownEditorContextValue = {
   id: string;
-  setEditorView: (view: EditorView) => void;
-  extensions: Extension[];
+  attendableId?: string;
   previewBlocks: PreviewBlock[];
-  toolbarState: Live<EditorToolbarState>;
-  popoverMenu: Omit<UsePopoverMenu, 'extension'>;
-} & (Pick<ExtensionsOptions, 'viewMode'> &
-  Pick<NaturalMarkdownToolbarProps, 'editorView' | 'onFileUpload' | 'onViewModeChange'>);
+} & Pick<ExtensionsOptions, 'compact' | 'viewMode'> &
+  Pick<NaturalMarkdownToolbarProps, 'onAction' | 'onFileUpload' | 'onViewModeChange'>;
 
 const [MarkdownEditorContextProvider, useMarkdownEditorContext] =
   createContext<MarkdownEditorContextValue>('MarkdownEditor.Context');
 
+/**
+ * Props to spread onto `Editor.Root` from `MarkdownEditorProvider`'s render callback.
+ */
+export type MarkdownEditorEditorRootProps = Omit<EditorRootProps, 'children'>;
+
 //
-// MarkdownEditor.Root
+// MarkdownEditorProvider
 //
 
-type MarkdownEditorRootProps = PropsWithChildren<
-  {
-    object?: DocumentType;
-    extensions?: Extension[];
-  } & Pick<MarkdownEditorContextValue, 'id' | 'onFileUpload' | 'onViewModeChange' | 'viewMode'> &
-    Pick<UsePopoverMenuOptionsProps, 'slashCommandGroups' | 'onLinkQuery'> &
-    Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings'>
->;
-
-const MarkdownEditorRoot = ({
+export type MarkdownEditorProviderProps = {
+  object?: DocumentType;
+  extensions?: Extension[];
+  children: (editorRootProps: MarkdownEditorEditorRootProps) => ReactNode;
+} & Pick<
+  MarkdownEditorContextValue,
+  'id' | 'attendableId' | 'viewMode' | 'compact' | 'onAction' | 'onFileUpload' | 'onViewModeChange'
+> &
+  Pick<UseEditorMenuOptionsProps, 'slashCommandGroups' | 'onLinkQuery'> &
+  Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings' | 'onSelectObject'>;
+
+export const MarkdownEditorProvider = ({
   children,
   id,
+  attendableId,
   object,
-  editorStateStore,
-  selectionManager,
   settings,
+  compact,
   viewMode,
-  extensions: extensionsParam,
+  selectionManager,
+  editorStateStore,
+  extensions: extensionsProp,
   slashCommandGroups,
   onLinkQuery,
-  ...props
-}: MarkdownEditorRootProps) => {
-  const [editorView, setEditorView] = useState<EditorView>();
-
+  onSelectObject,
+  onAction,
+  onFileUpload,
+  onViewModeChange,
+}: MarkdownEditorProviderProps) => {
   // Preview blocks.
   const [previewBlocks, setPreviewBlocks] = useState<PreviewBlock[]>([]);
   const previewOptions = useMemo<PreviewOptions>(
     () => ({
+      db: Obj.isObject(object) ? Obj.getDatabase(object) : undefined,
       addBlockContainer: (block) => {
         setPreviewBlocks((prev) => [...prev, block]);
       },
       removeBlockContainer: ({ link }) => {
-        setPreviewBlocks((prev) => prev.filter(({ link: prevLink }) => prevLink.ref !== link.ref));
+        setPreviewBlocks((prev) => prev.filter(({ link: prevLink }) => prevLink.dxn !== link.dxn));
       },
     }),
-    [],
+    [object],
   );
 
-  // Toolbar state.
-  const toolbarState = useEditorToolbarState({ viewMode });
-
-  // Context menu.
-  const menuOptions = usePopoverMenuOptions({
-    editorView,
-    slashCommandGroups,
-    onLinkQuery,
-  });
-  const { extension: menuExtension, ...menuProps } = usePopoverMenu(menuOptions);
+  // Context menu options (Editor.Root calls useEditorMenu with these props).
+  const menuOptions = useEditorMenuOptions({ slashCommandGroups, onLinkQuery });
 
-  // Extensions.
+  // Core markdown extensions (popover/menu extension is added by Editor.Root).
   const coreExtensions = useExtensions({
     id,
     object,
+    compact,
+    viewMode,
+    selectionManager,
     editorStateStore,
     previewOptions,
-    selectionManager,
     settings,
-    viewMode,
+    onSelectObject,
   });
 
   const extensions = useMemo(
-    () => [coreExtensions, menuExtension, extensionsParam].filter(isNonNullable),
-    [coreExtensions, menuExtension, extensionsParam],
+    () => [coreExtensions, extensionsProp].filter(isNonNullable).flat(),
+    [coreExtensions, extensionsProp],
+  );
+
+  const editorRootProps = useMemo<MarkdownEditorEditorRootProps>(
+    () => ({
+      extensions,
+      viewMode,
+      getMenu: menuOptions.getMenu,
+      trigger: menuOptions.trigger,
+      placeholder: menuOptions.placeholder,
+      ...(menuOptions.filter !== undefined ? { filter: menuOptions.filter } : {}),
+      ...(menuOptions.triggerKey !== undefined ? { triggerKey: menuOptions.triggerKey } : {}),
+    }),
+    [extensions, viewMode, menuOptions],
+  );
+
+  const markdownContextValue = useMemo<MarkdownEditorContextValue>(
+    () => ({
+      id,
+      attendableId,
+      compact,
+      viewMode,
+      previewBlocks,
+      onAction,
+      onFileUpload,
+      onViewModeChange,
+    }),
+    [id, attendableId, compact, viewMode, previewBlocks, onAction, onFileUpload, onViewModeChange],
   );
 
   return (
-    <MarkdownEditorContextProvider
-      id={id}
-      editorView={editorView}
-      setEditorView={setEditorView}
-      extensions={extensions}
-      previewBlocks={previewBlocks}
-      toolbarState={toolbarState}
-      popoverMenu={menuProps}
-      viewMode={viewMode}
-      {...props}
-    >
-      {children}
-    </MarkdownEditorContextProvider>
+    <MarkdownEditorContextProvider {...markdownContextValue}>{children(editorRootProps)}</MarkdownEditorContextProvider>
   );
 };
 
-MarkdownEditorRoot.displayName = 'MarkdownEditor.Root';
+MarkdownEditorProvider.displayName = 'MarkdownEditor.Provider';
 
 //
-// MarkdownEditor.Main
+// MarkdownEditor.Content
 //
 
+const MARKDOWN_EDITOR_CONTENT_NAME = 'MarkdownEditor.Content';
+
 type MarkdownEditorContentProps = Omit<NaturalMarkdownEditorContentProps, 'id' | 'extensions' | 'toolbarState'>;
 
-const MarkdownEditorContent = (props: MarkdownEditorContentProps) => {
-  const {
-    id,
-    extensions,
-    editorView,
-    setEditorView,
-    toolbarState,
-    viewMode,
-    popoverMenu: { groupsRef, ...menuProps },
-  } = useMarkdownEditorContext(MarkdownEditorContent.displayName);
+const MarkdownEditorContent = composable<HTMLDivElement, MarkdownEditorContentProps>(
+  ({ compact: compactProp, ...props }, _forwardedRef) => {
+    const {
+      id,
+      attendableId,
+      compact = compactProp,
+      viewMode,
+      onFileUpload,
+    } = useMarkdownEditorContext(MARKDOWN_EDITOR_CONTENT_NAME);
+    const { extensions, setController, state } = useEditorContext(MARKDOWN_EDITOR_CONTENT_NAME);
+
+    const handleRef = useCallback(
+      (view: EditorView | null) => {
+        setController(createEditorController(view));
+      },
+      [setController],
+    );
 
-  return (
-    <PopoverMenuProvider view={editorView} groups={groupsRef.current} {...menuProps}>
+    return (
       <NaturalMarkdownEditorContent
-        {...props}
+        {...composableProps(props)}
         id={id}
-        extensions={extensions}
-        toolbarState={toolbarState}
+        attendableId={attendableId}
+        compact={compact}
         viewMode={viewMode}
-        ref={setEditorView}
+        toolbarState={state as Atom.Writable<EditorToolbarState>}
+        extensions={extensions}
+        onFileUpload={onFileUpload}
+        ref={handleRef}
       />
-    </PopoverMenuProvider>
-  );
-};
+    );
+  },
+);
 
-MarkdownEditorContent.displayName = 'MarkdownEditor.Content';
+MarkdownEditorContent.displayName = MARKDOWN_EDITOR_CONTENT_NAME;
 
 //
 // MarkdownEditor.Toolbar
 //
 
-type MarkdownEditorToolbarProps = Omit<
-  NaturalMarkdownToolbarProps,
-  'state' | 'editorView' | 'onFileUpload' | 'onViewModeChange'
+const MARKDOWN_EDITOR_TOOLBAR_NAME = 'MarkdownEditor.Toolbar';
+
+type MarkdownEditorToolbarProps = ThemedClassName<
+  Omit<NaturalMarkdownToolbarProps, 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange' | 'id'>
 >;
 
 const MarkdownEditorToolbar = (props: MarkdownEditorToolbarProps) => {
-  const { toolbarState, ...rootProps } = useMarkdownEditorContext(MarkdownEditorToolbar.displayName);
+  const { id, attendableId, onAction, onFileUpload, onViewModeChange } =
+    useMarkdownEditorContext(MARKDOWN_EDITOR_TOOLBAR_NAME);
 
-  return <NaturalMarkdownToolbar {...props} {...rootProps} state={toolbarState} />;
+  const { controller } = useEditorContext(MARKDOWN_EDITOR_TOOLBAR_NAME);
+
+  return (
+    <NaturalMarkdownToolbar
+      {...props}
+      id={attendableId ?? id}
+      editorView={controller?.view ?? undefined}
+      onAction={onAction}
+      onFileUpload={onFileUpload}
+      onViewModeChange={onViewModeChange}
+    />
+  );
 };
 
-MarkdownEditorToolbar.displayName = 'MarkdownEditor.Toolbar';
+MarkdownEditorToolbar.displayName = MARKDOWN_EDITOR_TOOLBAR_NAME;
 
 //
 // MarkdownEditor.Blocks (embedded objects)
 //
 
+const MARKDOWN_EDITOR_BLOCKS_NAME = 'MarkdownEditor.Blocks';
+
 type MarkdownEditorBlocksProps = {};
 
 const MarkdownEditorBlocks = (_props: MarkdownEditorBlocksProps) => {
-  const { previewBlocks } = useMarkdownEditorContext(MarkdownEditorBlocks.displayName);
+  const { previewBlocks } = useMarkdownEditorContext(MARKDOWN_EDITOR_BLOCKS_NAME);
 
   return (
     <>
       {previewBlocks.map(({ link, el }) => (
-        <PreviewBlock key={link.ref} link={link} el={el} />
+        <PreviewBlock key={link.dxn} link={link} el={el} />
       ))}
     </>
   );
 };
 
-MarkdownEditorBlocks.displayName = 'MarkdownEditor.Blocks';
+MarkdownEditorBlocks.displayName = MARKDOWN_EDITOR_BLOCKS_NAME;
 
 const PreviewBlock = ({ el, link }: PreviewBlock) => {
   const client = useClient();
-  const dxn = DXN.parse(link.ref);
-  const subject = client.graph.ref(dxn).target;
+  const dxn = DXN.parse(link.dxn);
+  const subject = client.graph.makeRef(dxn).target;
   const data = useMemo(() => ({ subject }), [subject]);
 
-  return createPortal(<Surface role='card--transclusion' data={data} limit={1} />, el);
+  return createPortal(<Surface.Surface type={AppSurface.Card} data={data} limit={1} />, el);
 };
 
 //
 // MarkdownEditor
 //
 
+/** @private */
 export const MarkdownEditor = {
-  Root: MarkdownEditorRoot,
   Content: MarkdownEditorContent,
   Toolbar: MarkdownEditorToolbar,
   Blocks: MarkdownEditorBlocks,
 };
 
-export type {
-  MarkdownEditorRootProps,
-  MarkdownEditorContentProps,
-  MarkdownEditorToolbarProps,
-  MarkdownEditorBlocksProps,
-};
+export type { MarkdownEditorContentProps, MarkdownEditorToolbarProps, MarkdownEditorBlocksProps };
+
+/** @deprecated Use `MarkdownEditorProviderProps`. */
+export type MarkdownEditorRootProps = MarkdownEditorProviderProps;

package/src/components/MarkdownEditor/MarkdownEditorContent.tsx

@@ -3,56 +3,87 @@
 //
 
 import { type EditorView } from '@codemirror/view';
-import React, { forwardRef, useEffect, useImperativeHandle, useMemo } from 'react';
+import { type Atom, RegistryContext } from '@effect-atom/atom-react';
+import React, { forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo } from 'react';
 
-import { type Live } from '@dxos/live-object';
-import { useDynamicRef, useThemeContext, useTranslation } from '@dxos/react-ui';
+import { useCapabilities } from '@dxos/app-framework/ui';
+import { type ThemedClassName, useThemeContext, useTranslation } from '@dxos/react-ui';
 import {
-  type EditorSelectionState,
-  type EditorStateStore,
+  type EditorMenuGroup,
   type EditorToolbarState,
-  type EditorViewMode,
-  type PopoverMenuGroup,
   type UseTextEditorProps,
+  useTextEditor,
+} from '@dxos/react-ui-editor';
+import {
+  type EditorSelectionState,
+  type EditorStateStore,
+  type ThemeExtensionsOptions,
+  mobileSlots,
   createBasicExtensions,
   createMarkdownExtensions,
   createThemeExtensions,
   dropFile,
-  editorGutter,
-  editorSlots,
+  documentSlots,
   formattingListener,
   processEditorPayload,
-  stackItemContentEditorClassNames,
-  useTextEditor,
-} from '@dxos/react-ui-editor';
+  editorClassNames,
+} from '@dxos/ui-editor';
+import { type EditorViewMode } from '@dxos/ui-editor/types';
+import { mx } from '@dxos/ui-theme';
 import { isTruthy } from '@dxos/util';
 
-import { useSelectCurrentThread } from '../../hooks';
-import { meta } from '../../meta';
+import { meta } from '#meta';
+import { MarkdownCapabilities } from '#types';
 
 import { type MarkdownEditorToolbarProps } from './MarkdownEditorToolbar';
 
-export type MarkdownEditorContentProps = {
+export type MarkdownEditorContentProps = ThemedClassName<{
   id: string;
+  attendableId?: string;
   role?: string;
+  compact?: boolean;
   viewMode?: EditorViewMode;
-  scrollPastEnd?: boolean;
-  slashCommandGroups?: PopoverMenuGroup[];
+  slashCommandGroups?: EditorMenuGroup[];
   editorStateStore?: EditorStateStore;
-  toolbarState?: Live<EditorToolbarState>;
-  onLinkQuery?: (query?: string) => Promise<PopoverMenuGroup[]>;
-} & (Pick<UseTextEditorProps, 'initialValue' | 'extensions'> & Pick<MarkdownEditorToolbarProps, 'onFileUpload'>);
+  toolbarState?: Atom.Writable<EditorToolbarState>;
+  onLinkQuery?: (query?: string) => Promise<EditorMenuGroup[]>;
+}> &
+  Pick<UseTextEditorProps, 'initialValue' | 'extensions'> &
+  Pick<MarkdownEditorToolbarProps, 'onFileUpload'> &
+  Pick<ThemeExtensionsOptions, 'slots'>;
 
+// TODO(burdon): Move controller to Root.
 export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEditorContentProps>(
   (
-    { id, role, initialValue, editorStateStore, toolbarState, extensions, viewMode, scrollPastEnd, onFileUpload },
+    {
+      classNames,
+      id,
+      attendableId,
+      role,
+      compact,
+      viewMode,
+      initialValue,
+      editorStateStore,
+      toolbarState,
+      extensions,
+      slots,
+      onFileUpload,
+    },
     forwardedRef,
   ) => {
     const { t } = useTranslation(meta.id);
     const { themeMode } = useThemeContext();
+    const registry = useContext(RegistryContext);
 
-    // TODO(burdon): Toolbar state is not reactive.
-    const toolbarStateRef = useDynamicRef(toolbarState);
+    // Callback to update toolbar state atom.
+    const updateToolbarState = useCallback(
+      (formatting: EditorToolbarState) => {
+        if (toolbarState) {
+          registry.set(toolbarState, { ...registry.get(toolbarState), ...formatting });
+        }
+      },
+      [registry, toolbarState],
+    );
 
     // Restore last selection and scroll point.
     const { scrollTo, selection } = useMemo<EditorSelectionState>(() => editorStateStore?.getState(id) ?? {}, [id]);
@@ -67,26 +98,23 @@ export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEdito
           id,
           scrollTo,
           selection,
-          // TODO(wittjosiah): Autofocus based on layout is racy.
-          // autoFocus: layoutPlugin?.provides.layout ? layoutPlugin?.provides.layout.scrollIntoView === id : true,
-          moveToEndOfLine: true,
+          selectionEnd: true,
         }),
         initialValue,
         extensions: [
           createBasicExtensions({
             readOnly: viewMode === 'readonly',
-            placeholder: t('editor placeholder'),
-            scrollPastEnd: scrollPastEnd && role !== 'section',
+            placeholder: t('editor.placeholder'),
+            scrollPastEnd: !compact,
             search: true,
           }),
           createThemeExtensions({
             themeMode,
-            slots: editorSlots,
+            slots: slots ?? (compact ? mobileSlots : documentSlots),
             syntaxHighlighting: true,
           }),
           createMarkdownExtensions(),
-          formattingListener(() => toolbarStateRef.current),
-          editorGutter,
+          toolbarState && formattingListener(updateToolbarState),
           role !== 'section' &&
             onFileUpload &&
             dropFile({
@@ -102,21 +130,28 @@ export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEdito
           extensions,
         ].filter(isTruthy),
       }),
-      [id, viewMode, themeMode, extensions],
+      [id, viewMode, themeMode, extensions, compact],
     );
 
     useImperativeHandle<EditorView | null, EditorView | null>(forwardedRef, () => editorView, [editorView]);
-    useSelectCurrentThread(editorView, id);
+
+    const [editorViewRegistry] = useCapabilities(MarkdownCapabilities.EditorViews);
+    useEffect(() => {
+      if (editorView && editorViewRegistry) {
+        editorViewRegistry.register(attendableId ?? id, editorView, id);
+        return () => editorViewRegistry.unregister(attendableId ?? id);
+      }
+    }, [editorView, editorViewRegistry, attendableId, id]);
+
     useTest(editorView);
 
     return (
       <div
-        role='none'
-        ref={parentRef}
+        {...focusAttributes}
+        className={mx(editorClassNames(role), classNames)}
         data-testid='composer.markdownRoot'
-        className={stackItemContentEditorClassNames(role)}
         data-popover-collision-boundary={true}
-        {...focusAttributes}
+        ref={parentRef}
       />
     );
   },

package/src/components/MarkdownEditor/MarkdownEditorToolbar.tsx

@@ -5,59 +5,43 @@
 import { type EditorView } from '@codemirror/view';
 import React, { useCallback, useState } from 'react';
 
-import { type FileInfo } from '@dxos/app-framework';
-import { invariant } from '@dxos/invariant';
-import { type ThemedClassName } from '@dxos/react-ui';
-import { EditorToolbar, type EditorToolbarProps, type EditorViewMode } from '@dxos/react-ui-editor';
+import { type FileInfo } from '@dxos/app-toolkit';
+import { Editor, type EditorToolbarProps } from '@dxos/react-ui-editor';
+import { composable, composableProps } from '@dxos/ui-theme';
 
 import { FileUpload, type FileUploadAction } from './FileUpload';
 
-export type MarkdownEditorToolbarProps = ThemedClassName<
-  {
-    id: string;
-    editorView?: EditorView;
-    onFileUpload?: (file: File) => Promise<FileInfo | undefined>;
-  } & Pick<EditorToolbarProps, 'role' | 'state' | 'customActions' | 'onViewModeChange'>
->;
-
-export const MarkdownEditorToolbar = ({
-  classNames,
-  id,
-  role,
-  state,
-  editorView,
-  customActions,
-  onFileUpload,
-  onViewModeChange,
-}: MarkdownEditorToolbarProps) => {
-  const [upload, setUpload] = useState<FileUploadAction | null>(null);
-  const handleRef = useCallback((next: FileUploadAction) => setUpload(() => next), []);
-
-  const handleViewModeChange = useCallback((mode: EditorViewMode) => onViewModeChange?.(mode), [onViewModeChange]);
-
-  const getView = useCallback(() => {
-    invariant(editorView);
-    return editorView;
-  }, [editorView]);
-
-  if (!editorView) {
-    return <div />;
-  }
-
-  return (
-    <>
-      <EditorToolbar
-        classNames={classNames}
-        attendableId={id}
-        role={role}
-        state={state}
-        customActions={customActions}
-        getView={getView}
-        onImageUpload={upload ?? undefined}
-        onViewModeChange={handleViewModeChange}
-      />
-
-      {onFileUpload && <FileUpload ref={handleRef} editorView={editorView} onFileUpload={onFileUpload} />}
-    </>
-  );
-};
+export type MarkdownEditorToolbarProps = {
+  id: string;
+  editorView?: EditorView;
+  onFileUpload?: (file: File) => Promise<FileInfo | undefined>;
+} & Pick<EditorToolbarProps, 'role' | 'customActions' | 'onAction' | 'onViewModeChange'>;
+
+export const MarkdownEditorToolbar = composable<HTMLDivElement, MarkdownEditorToolbarProps>(
+  ({ id, role, editorView, customActions, onAction, onFileUpload, onViewModeChange, ...props }, forwardedRef) => {
+    const { className, ...rest } = composableProps(props);
+    const [upload, setUpload] = useState<FileUploadAction | null>(null);
+    const uploadRef = useCallback((next: FileUploadAction) => setUpload(() => next), []);
+
+    if (!editorView) {
+      return <div className={className} {...rest} ref={forwardedRef} />;
+    }
+
+    return (
+      <div className='contents' ref={forwardedRef}>
+        <Editor.Toolbar
+          {...rest}
+          classNames={className}
+          attendableId={id}
+          role={role}
+          customActions={customActions}
+          onAction={onAction}
+          onImageUpload={upload ?? undefined}
+          onViewModeChange={onViewModeChange}
+        />
+
+        {onFileUpload && <FileUpload ref={uploadRef} editorView={editorView} onFileUpload={onFileUpload} />}
+      </div>
+    );
+  },
+);