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

package/src/cli/plugin.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
+import { type CreateObject } from '@dxos/plugin-space/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { Text } from '@dxos/schema';
+
+import { OperationHandler } from '#capabilities';
+
+import { meta } from '#meta';
+import { Markdown } from '#types';
+
+export const MarkdownPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Markdown.Document.typename,
+      metadata: {
+        createObject: ((props, options) =>
+          Effect.gen(function* () {
+            const object = Markdown.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          })) satisfies CreateObject,
+      },
+    },
+  }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({ schema: [Markdown.Document, Text.Text] }),
+  Plugin.make,
+);

package/src/components/MarkdownEditor/FileUpload.tsx

@@ -7,8 +7,8 @@ import React, { forwardRef, useEffect, useImperativeHandle } from 'react';
 import { createPortal } from 'react-dom';
 import { useDropzone } from 'react-dropzone';
 
-import { type FileInfo } from '@dxos/app-framework';
-import { addLink } from '@dxos/react-ui-editor';
+import { type FileInfo } from '@dxos/app-toolkit';
+import { addLink } from '@dxos/ui-editor';
 
 export const IMAGE_FILES = ['.jpg', '.jpeg', '.png', '.gif'];
 

package/src/components/MarkdownEditor/MarkdownEditor.stories.tsx

@@ -3,73 +3,71 @@
 //
 
 import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { IntentPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
-import { Filter } from '@dxos/echo';
-import { AttentionPlugin } from '@dxos/plugin-attention';
+import { Filter, Obj } from '@dxos/echo';
 import { ClientPlugin } from '@dxos/plugin-client';
-import { fullyQualifiedId, useQuery, useSpace } from '@dxos/react-client/echo';
-import { withLayout, withTheme } from '@dxos/react-ui/testing';
-import { useAttentionAttributes } from '@dxos/react-ui-attention';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { useQuery, useSpace } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+import { AttendableContainer } from '@dxos/react-ui-attention';
 import { translations as editorTranslations } from '@dxos/react-ui-editor';
-import { StackItem } from '@dxos/react-ui-stack';
+import { Text } from '@dxos/schema';
 
 import { translations } from '../../translations';
-import { Markdown } from '../../types';
+import { Markdown } from '#types';
 
 import { MarkdownEditor, type MarkdownEditorRootProps } from './MarkdownEditor';
 
-const content = Array.from({ length: 100 }, (_, i) => `Line ${i + 1}`).join('\n');
+type DefaultStoryProps = Omit<MarkdownEditorRootProps, 'id' | 'extensions'>;
 
-type StoryProps = Omit<MarkdownEditorRootProps, 'id' | 'extensions'>;
-
-const DefaultStory = (props: StoryProps) => {
+const DefaultStory = (props: DefaultStoryProps) => {
   const space = useSpace();
   const [doc] = useQuery(space?.db, Filter.type(Markdown.Document));
-  const id = doc && fullyQualifiedId(doc);
-  const attentionAttrs = useAttentionAttributes(id);
-
+  const id = doc && Obj.getDXN(doc).toString();
   if (!id) {
-    return null;
+    return <Loading data={{ id }} />;
   }
 
-  // TODO(burdon): Toolbar attention isn't working in this story.
   return (
-    <div className='contents' {...attentionAttrs}>
-      <StackItem.Content toolbar>
-        <MarkdownEditor.Root id={id} object={doc} {...props}>
-          <MarkdownEditor.Toolbar id={id} />
-          <MarkdownEditor.Content />
-        </MarkdownEditor.Root>
-      </StackItem.Content>
-    </div>
+    <AttendableContainer id={id} tabIndex={0} classNames='dx-container'>
+      <MarkdownEditor.Root id={id} object={doc} {...props}>
+        <Panel.Root>
+          <Panel.Toolbar asChild>
+            <MarkdownEditor.Toolbar />
+          </Panel.Toolbar>
+          <Panel.Content asChild>
+            <MarkdownEditor.Content />
+          </Panel.Content>
+        </Panel.Root>
+      </MarkdownEditor.Root>
+    </AttendableContainer>
   );
 };
 
 const meta: Meta<typeof DefaultStory> = {
-  title: 'plugins/plugin-markdown/MarkdownEditor',
-  component: DefaultStory,
-  render: DefaultStory as any,
+  title: 'plugins/plugin-markdown/components/MarkdownEditor',
+  render: DefaultStory,
   decorators: [
-    withTheme,
-    withLayout({ container: 'column' }),
-    // TODO(burdon): Create story without client.
+    withLayout({ layout: 'column' }),
     withPluginManager({
       plugins: [
+        ...corePlugins(),
+        // TODO(burdon): Try to write story without ClientPlugin.
         ClientPlugin({
-          types: [Markdown.Document],
-          onClientInitialized: async ({ client }) => {
-            await client.halo.createIdentity();
-            await client.spaces.waitUntilReady();
-            const space = client.spaces.default;
-            await space.waitUntilReady();
-            space.db.add(Markdown.makeDocument({ content }));
-          },
+          types: [Markdown.Document, Text.Text],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+              personalSpace.db.add(
+                Markdown.make({ content: Array.from({ length: 100 }, (_, i) => `Line ${i + 1}`).join('\n') }),
+              );
+            }),
         }),
-        IntentPlugin(),
-        AttentionPlugin(),
       ],
     }),
   ],

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 { createPortal } from 'react-dom';
 
-import { Surface } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/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 {
+  EditorMenuProvider,
   type EditorToolbarState,
-  PopoverMenuProvider,
-  type PreviewBlock,
-  type PreviewOptions,
-  type UsePopoverMenu,
-  useEditorToolbarState,
-  usePopoverMenu,
+  type UseEditorMenu,
+  useEditorMenu,
+  useEditorToolbar,
 } 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,13 +48,14 @@ import {
 
 type MarkdownEditorContextValue = {
   id: string;
+  attendableId?: string;
   setEditorView: (view: EditorView) => void;
   extensions: Extension[];
   previewBlocks: PreviewBlock[];
-  toolbarState: Live<EditorToolbarState>;
-  popoverMenu: Omit<UsePopoverMenu, 'extension'>;
-} & (Pick<ExtensionsOptions, 'viewMode'> &
-  Pick<NaturalMarkdownToolbarProps, 'editorView' | 'onFileUpload' | 'onViewModeChange'>);
+  toolbarState: Atom.Writable<EditorToolbarState>;
+  popoverMenu: Omit<UseEditorMenu, 'extension'>;
+} & (Pick<ExtensionsOptions, 'compact' | 'viewMode'> &
+  Pick<NaturalMarkdownToolbarProps, 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange'>);
 
 const [MarkdownEditorContextProvider, useMarkdownEditorContext] =
   createContext<MarkdownEditorContextValue>('MarkdownEditor.Context');
@@ -65,22 +68,28 @@ type MarkdownEditorRootProps = PropsWithChildren<
   {
     object?: DocumentType;
     extensions?: Extension[];
-  } & Pick<MarkdownEditorContextValue, 'id' | 'onFileUpload' | 'onViewModeChange' | 'viewMode'> &
-    Pick<UsePopoverMenuOptionsProps, 'slashCommandGroups' | 'onLinkQuery'> &
-    Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings'>
+  } & Pick<
+    MarkdownEditorContextValue,
+    'id' | 'attendableId' | 'viewMode' | 'compact' | 'onAction' | 'onFileUpload' | 'onViewModeChange'
+  > &
+    Pick<UseEditorMenuOptionsProps, 'slashCommandGroups' | 'onLinkQuery'> &
+    Pick<ExtensionsOptions, 'editorStateStore' | 'selectionManager' | 'settings' | 'onSelectObject'>
 >;
 
 const MarkdownEditorRoot = ({
   children,
   id,
+  attendableId,
   object,
-  editorStateStore,
-  selectionManager,
   settings,
+  compact,
   viewMode,
-  extensions: extensionsParam,
+  selectionManager,
+  editorStateStore,
+  extensions: extensionsProp,
   slashCommandGroups,
   onLinkQuery,
+  onSelectObject,
   ...props
 }: MarkdownEditorRootProps) => {
   const [editorView, setEditorView] = useState<EditorView>();
@@ -89,46 +98,47 @@ const MarkdownEditorRoot = ({
   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 });
+  const toolbarState = useEditorToolbar({ viewMode });
 
   // Context menu.
-  const menuOptions = usePopoverMenuOptions({
-    editorView,
-    slashCommandGroups,
-    onLinkQuery,
-  });
-  const { extension: menuExtension, ...menuProps } = usePopoverMenu(menuOptions);
+  const menuOptions = useEditorMenuOptions({ editorView, slashCommandGroups, onLinkQuery });
+  const { extension: menuExtension, ...menuProps } = useEditorMenu(menuOptions);
 
   // Extensions.
   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, menuExtension, extensionsProp].filter(isNonNullable),
+    [coreExtensions, menuExtension, extensionsProp],
   );
 
   return (
     <MarkdownEditorContextProvider
       id={id}
+      attendableId={attendableId}
+      compact={compact}
       editorView={editorView}
       setEditorView={setEditorView}
       extensions={extensions}
@@ -149,79 +159,99 @@ MarkdownEditorRoot.displayName = 'MarkdownEditor.Root';
 // MarkdownEditor.Main
 //
 
+const MARKDOWN_EDITOR_CONTENT_NAME = 'MarkdownEditor.Content';
+
 type MarkdownEditorContentProps = Omit<NaturalMarkdownEditorContentProps, 'id' | 'extensions' | 'toolbarState'>;
 
-const MarkdownEditorContent = (props: MarkdownEditorContentProps) => {
+const MarkdownEditorContent = composable<HTMLDivElement, MarkdownEditorContentProps>(({ ...props }, _forwardedRef) => {
   const {
     id,
-    extensions,
+    attendableId,
+    compact,
     editorView,
     setEditorView,
-    toolbarState,
     viewMode,
+    toolbarState,
+    extensions,
     popoverMenu: { groupsRef, ...menuProps },
-  } = useMarkdownEditorContext(MarkdownEditorContent.displayName);
+  } = useMarkdownEditorContext(MARKDOWN_EDITOR_CONTENT_NAME);
 
   return (
-    <PopoverMenuProvider view={editorView} groups={groupsRef.current} {...menuProps}>
+    <EditorMenuProvider view={editorView} groups={groupsRef.current} {...menuProps}>
       <NaturalMarkdownEditorContent
-        {...props}
+        {...composableProps(props)}
         id={id}
-        extensions={extensions}
-        toolbarState={toolbarState}
+        attendableId={attendableId}
+        compact={compact}
         viewMode={viewMode}
+        toolbarState={toolbarState}
+        extensions={extensions}
         ref={setEditorView}
       />
-    </PopoverMenuProvider>
+    </EditorMenuProvider>
   );
-};
+});
 
-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, 'state' | 'editorView' | 'onAction' | 'onFileUpload' | 'onViewModeChange' | 'id'>
 >;
 
 const MarkdownEditorToolbar = (props: MarkdownEditorToolbarProps) => {
-  const { toolbarState, ...rootProps } = useMarkdownEditorContext(MarkdownEditorToolbar.displayName);
+  const { id, attendableId, editorView, toolbarState, onAction, onFileUpload, onViewModeChange } =
+    useMarkdownEditorContext(MARKDOWN_EDITOR_TOOLBAR_NAME);
 
-  return <NaturalMarkdownToolbar {...props} {...rootProps} state={toolbarState} />;
+  return (
+    <NaturalMarkdownToolbar
+      {...props}
+      id={attendableId ?? id}
+      editorView={editorView}
+      state={toolbarState}
+      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 role='card--content' data={data} limit={1} />, el);
 };
 
 //

package/src/components/MarkdownEditor/MarkdownEditorContent.tsx

@@ -3,56 +3,86 @@
 //
 
 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 EditorMenuGroup,
+  type EditorToolbarState,
+  type UseTextEditorProps,
+  useTextEditor,
+} from '@dxos/react-ui-editor';
 import {
   type EditorSelectionState,
   type EditorStateStore,
-  type EditorToolbarState,
   type EditorViewMode,
-  type PopoverMenuGroup,
-  type UseTextEditorProps,
+  type ThemeExtensionsOptions,
+  compactSlots,
   createBasicExtensions,
   createMarkdownExtensions,
   createThemeExtensions,
   dropFile,
-  editorGutter,
-  editorSlots,
+  documentSlots,
   formattingListener,
   processEditorPayload,
-  stackItemContentEditorClassNames,
-  useTextEditor,
-} from '@dxos/react-ui-editor';
+  editorClassNames,
+} from '@dxos/ui-editor';
+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'>;
 
 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 +97,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 ? compactSlots : documentSlots),
             syntaxHighlighting: true,
           }),
           createMarkdownExtensions(),
-          formattingListener(() => toolbarStateRef.current),
-          editorGutter,
+          toolbarState && formattingListener(updateToolbarState),
           role !== 'section' &&
             onFileUpload &&
             dropFile({
@@ -106,17 +133,25 @@ export const MarkdownEditorContent = forwardRef<EditorView | null, MarkdownEdito
     );
 
     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
+        {...focusAttributes}
+        className={mx(editorClassNames(role), classNames)}
         role='none'
-        ref={parentRef}
         data-testid='composer.markdownRoot'
-        className={stackItemContentEditorClassNames(role)}
         data-popover-collision-boundary={true}
-        {...focusAttributes}
+        ref={parentRef}
       />
     );
   },