@dxos/plugin-markdown 0.8.4-main.67995b8 → 0.8.4-main.6fa680abb7

package/src/components/MarkdownEditor/MarkdownEditorContent.tsx

@@ -0,0 +1,163 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+import { type Atom, RegistryContext } from '@effect-atom/atom-react';
+import React, { forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo } from 'react';
+
+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 EditorViewMode,
+  type ThemeExtensionsOptions,
+  createBasicExtensions,
+  createMarkdownExtensions,
+  createThemeExtensions,
+  dropFile,
+  editorSlots,
+  formattingListener,
+  processEditorPayload,
+  stackItemContentEditorClassNames,
+} from '@dxos/ui-editor';
+import { mx } from '@dxos/ui-theme';
+import { isTruthy } from '@dxos/util';
+
+import { useSelectCurrentThread } from '../../hooks';
+import { meta } from '../../meta';
+
+import { type MarkdownEditorToolbarProps } from './MarkdownEditorToolbar';
+
+export type MarkdownEditorContentProps = ThemedClassName<{
+  id: string;
+  attendableId?: string;
+  role?: string;
+  viewMode?: EditorViewMode;
+  scrollPastEnd?: boolean;
+  slashCommandGroups?: EditorMenuGroup[];
+  editorStateStore?: EditorStateStore;
+  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>(
+  (
+    {
+      classNames,
+      id,
+      attendableId,
+      role,
+      viewMode,
+      initialValue,
+      editorStateStore,
+      toolbarState,
+      extensions,
+      scrollPastEnd,
+      slots = editorSlots,
+      onFileUpload,
+    },
+    forwardedRef,
+  ) => {
+    const { t } = useTranslation(meta.id);
+    const { themeMode } = useThemeContext();
+    const registry = useContext(RegistryContext);
+
+    // 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]);
+
+    const {
+      parentRef,
+      view: editorView,
+      focusAttributes,
+    } = useTextEditor(
+      () => ({
+        ...(role !== 'section' && {
+          id,
+          scrollTo,
+          selection,
+          // TODO(wittjosiah): Autofocus based on layout is racy.
+          // autoFocus: layoutPlugin?.provides.layout ? layoutPlugin?.provides.layout.scrollIntoView === id : true,
+          selectionEnd: true,
+        }),
+        initialValue,
+        extensions: [
+          createBasicExtensions({
+            readOnly: viewMode === 'readonly',
+            placeholder: t('editor placeholder'),
+            scrollPastEnd: scrollPastEnd && role !== 'section',
+            search: true,
+          }),
+          createThemeExtensions({
+            themeMode,
+            slots,
+            syntaxHighlighting: true,
+          }),
+          createMarkdownExtensions(),
+          toolbarState && formattingListener(updateToolbarState),
+          role !== 'section' &&
+            onFileUpload &&
+            dropFile({
+              // TODO(wittjosiah): Factor out to file uploader plugin.
+              onDrop: async (view, { files }) => {
+                const file = files[0];
+                const info = file && onFileUpload ? await onFileUpload(file) : undefined;
+                if (info) {
+                  processEditorPayload(view, { type: 'image', data: info.url });
+                }
+              },
+            }),
+          extensions,
+        ].filter(isTruthy),
+      }),
+      [id, viewMode, themeMode, extensions],
+    );
+
+    useImperativeHandle<EditorView | null, EditorView | null>(forwardedRef, () => editorView, [editorView]);
+
+    useSelectCurrentThread(editorView, id, attendableId ?? id);
+
+    useTest(editorView);
+
+    return (
+      <div
+        {...focusAttributes}
+        role='none'
+        data-testid='composer.markdownRoot'
+        data-popover-collision-boundary={true}
+        className={mx(stackItemContentEditorClassNames(role), classNames)}
+        ref={parentRef}
+      />
+    );
+  },
+);
+
+// Expose editor view for playwright tests.
+// TODO(wittjosiah): Find a better way to expose this or find a way to limit it to test runs.
+const useTest = (view: EditorView | null) => {
+  useEffect(() => {
+    const composer = (window as any).composer;
+    if (composer) {
+      composer.editorView = view;
+    }
+  }, [view]);
+};

package/src/components/MarkdownEditor/MarkdownEditorToolbar.tsx

@@ -0,0 +1,67 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+import React, { type ComponentPropsWithoutRef, useCallback, useState } from 'react';
+
+import { type FileInfo } from '@dxos/app-toolkit';
+import { invariant } from '@dxos/invariant';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { EditorToolbar, type EditorToolbarProps } from '@dxos/react-ui-editor';
+import { type EditorViewMode } from '@dxos/ui-editor';
+
+import { FileUpload, type FileUploadAction } from './FileUpload';
+import { composableProps } from '@dxos/ui-theme';
+
+export type MarkdownEditorToolbarProps = ThemedClassName<
+  ComponentPropsWithoutRef<'div'> & {
+    id: string;
+    editorView?: EditorView;
+    onFileUpload?: (file: File) => Promise<FileInfo | undefined>;
+  } & Pick<EditorToolbarProps, 'role' | 'state' | 'customActions' | 'onAction' | 'onViewModeChange'>
+>;
+
+export const MarkdownEditorToolbar = ({
+  id,
+  role,
+  state,
+  editorView,
+  customActions,
+  onAction,
+  onFileUpload,
+  onViewModeChange,
+  ...props
+}: MarkdownEditorToolbarProps) => {
+  const { className, ...rest } = composableProps(props);
+  const [upload, setUpload] = useState<FileUploadAction | null>(null);
+  const uploadRef = useCallback((next: FileUploadAction) => setUpload(() => next), []);
+
+  const getView = useCallback(() => {
+    invariant(editorView);
+    return editorView;
+  }, [editorView]);
+
+  if (!editorView) {
+    return <div {...props} />;
+  }
+
+  return (
+    <div role='none' className='contents'>
+      <EditorToolbar
+        {...rest}
+        classNames={className}
+        attendableId={id}
+        role={role}
+        state={state}
+        customActions={customActions}
+        getView={getView}
+        onAction={onAction}
+        onImageUpload={upload ?? undefined}
+        onViewModeChange={onViewModeChange}
+      />
+
+      {onFileUpload && <FileUpload ref={uploadRef} editorView={editorView} onFileUpload={onFileUpload} />}
+    </div>
+  );
+};

package/src/components/index.ts

@@ -1,10 +1,5 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-import { lazy } from 'react';
-
-export * from './MarkdownSettings';
-
-export const MarkdownContainer = lazy(() => import('./MarkdownContainer'));
-export const MarkdownPreview = lazy(() => import('./MarkdownPreview'));
+export * from './MarkdownEditor';

package/src/containers/MarkdownCard/MarkdownCard.stories.tsx

@@ -0,0 +1,68 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useMemo } from 'react';
+
+import { OperationPlugin, RuntimePlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Obj } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { faker } from '@dxos/random';
+import { Card } from '@dxos/react-ui';
+import { withTheme } from '@dxos/react-ui/testing';
+import { CardContainer } from '@dxos/react-ui-mosaic/testing';
+
+import { translations } from '../../translations';
+
+import { MarkdownCard, type MarkdownCardProps } from './MarkdownCard';
+
+faker.seed(1234);
+
+const MarkdownCardStory = ({ ...args }: Omit<MarkdownCardProps, 'subject'>) => {
+  const subject = useMemo(
+    () =>
+      Markdown.make({
+        name: faker.lorem.words(3),
+        content: faker.lorem.paragraphs(5),
+      }),
+    [],
+  );
+
+  return (
+    <CardContainer icon='ph--text-aa--regular'>
+      <Card.Root border={false}>
+        <Card.Toolbar>
+          <Card.DragHandle />
+          <Card.Title>{Obj.getLabel(subject)}</Card.Title>
+          <Card.Menu />
+        </Card.Toolbar>
+        <MarkdownCard subject={subject} {...args} />
+      </Card.Root>
+    </CardContainer>
+  );
+};
+
+const meta: Meta<typeof MarkdownCardStory> = {
+  title: 'plugins/plugin-markdown/containers/MarkdownCard',
+  component: MarkdownCardStory,
+  decorators: [
+    withTheme(),
+    withPluginManager({
+      plugins: [OperationPlugin(), RuntimePlugin(), ClientPlugin({})],
+    }),
+  ],
+  parameters: {
+    layout: 'centered',
+    translations,
+  },
+  tags: ['cards'],
+};
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/MarkdownCard/MarkdownCard.tsx

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { Obj } from '@dxos/echo';
+import { useTranslation } from '@dxos/react-ui';
+import { Card } from '@dxos/react-ui';
+import { Text } from '@dxos/schema';
+
+import { MarkdownEditor } from '../../components';
+import { meta } from '../../meta';
+import { Markdown } from '../../types';
+import { getContentSnippet } from '../../util';
+
+export type MarkdownCardProps = { subject: Markdown.Document | Text.Text };
+
+export const MarkdownCard = ({ subject }: MarkdownCardProps) => {
+  const { t } = useTranslation(meta.id);
+  const snippet = useMemo(() => getSnippet(subject), [subject]);
+  const info = getInfo(subject);
+
+  return (
+    <Card.Content>
+      {snippet && (
+        <Card.Section>
+          <MarkdownEditor.Root id={subject.id} viewMode='readonly'>
+            <MarkdownEditor.Content
+              initialValue={snippet}
+              classNames='bg-transparent'
+              slots={{
+                editor: { className: 'max-h-[240px]' },
+              }}
+            />
+          </MarkdownEditor.Root>
+        </Card.Section>
+      )}
+      <Card.Section>
+        <Card.Text classNames='text-xs text-description'>
+          {info.words} {t('words label', { count: info.words })}
+        </Card.Text>
+      </Card.Section>
+    </Card.Content>
+  );
+};
+
+const MAX_LINES = 5;
+
+const getSnippet = (subject: Markdown.Document | Text.Text, fallback?: string) => {
+  if (Obj.instanceOf(Markdown.Document, subject)) {
+    return Obj.getDescription(subject) || getContentSnippet(subject.content?.target?.content ?? fallback, MAX_LINES);
+  } else if (Obj.instanceOf(Text.Text, subject)) {
+    return getContentSnippet(subject.content ?? fallback, MAX_LINES);
+  }
+};
+
+const getInfo = (subject: Markdown.Document | Text.Text) => {
+  const text = (Obj.instanceOf(Markdown.Document, subject) ? subject.content?.target?.content : subject.content) ?? '';
+  return { words: text.split(' ').length };
+};

package/src/containers/MarkdownCard/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { MarkdownCard } from './MarkdownCard';
+
+export default MarkdownCard;

package/src/containers/MarkdownContainer/MarkdownContainer.stories.tsx

@@ -0,0 +1,136 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React, { useMemo } from 'react';
+
+import { Capability, Plugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Surface, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppActivationEvents, LayoutOperation } from '@dxos/app-toolkit';
+import { Obj, Query } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { PreviewPlugin } from '@dxos/plugin-preview';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { faker } from '@dxos/random';
+import { useQuery, useSpace } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { useAttentionAttributes } from '@dxos/react-ui-attention';
+import { Text } from '@dxos/schema';
+import { type ValueGenerator, createObjectFactory } from '@dxos/schema/testing';
+import { Organization, Person } from '@dxos/types';
+
+import { MarkdownPlugin } from '../../MarkdownPlugin';
+import { translations } from '../../translations';
+import { Markdown, MarkdownCapabilities, MarkdownEvents } from '../../types';
+
+faker.seed(1);
+
+const generator: ValueGenerator = faker as any;
+
+/** Minimal plugin that contributes an empty Extensions capability for stories. */
+const MarkdownExtensionsPlugin = Plugin.define({ id: 'story-markdown-extensions', name: 'Story Extensions' }).pipe(
+  Plugin.addModule({
+    id: 'extensions',
+    activatesOn: MarkdownEvents.SetupExtensions,
+    activate: () => Effect.succeed(Capability.contributes(MarkdownCapabilities.Extensions, [])),
+  }),
+  Plugin.make,
+);
+
+const DefaultStory = () => {
+  const { invokePromise } = useOperationInvoker();
+  const space = useSpace();
+  const [doc] = useQuery(space?.db, Query.type(Markdown.Document));
+  const data = useMemo(() => ({ subject: doc }), [doc]);
+  const id = doc && Obj.getDXN(doc).toString();
+  const attentionAttrs = useAttentionAttributes(id);
+
+  useAsyncEffect(async () => {
+    if (space) {
+      await invokePromise(LayoutOperation.SwitchWorkspace, { subject: space.id });
+    }
+  }, [space, invokePromise]);
+
+  return (
+    <div className='contents' {...attentionAttrs}>
+      <Surface.Surface role='article' data={data} limit={1} />
+    </div>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-markdown/containers/MarkdownContainer',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'column' }),
+    withPluginManager<{ title?: string; content?: string }>((context) => ({
+      setupEvents: [AppActivationEvents.SetupSettings, MarkdownEvents.SetupExtensions],
+      plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        MarkdownExtensionsPlugin(),
+        ClientPlugin({
+          types: [Markdown.Document, Text.Text, Person.Person, Organization.Organization],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* Effect.promise(() => client.halo.createIdentity());
+              yield* Effect.promise(() => client.spaces.waitUntilReady());
+              yield* Effect.promise(() => client.spaces.default.waitUntilReady());
+
+              const space = client.spaces.default;
+              const createObjects = createObjectFactory(space.db, generator);
+              yield* Effect.promise(() => createObjects([{ type: Organization.Organization, count: 10 }]));
+
+              const queue = space.queues.create();
+              const kai = Obj.make(Person.Person, { fullName: 'Kai' });
+              const dxos = Obj.make(Organization.Organization, { name: 'DXOS' });
+              yield* Effect.promise(() => queue.append([kai, dxos]));
+
+              space.db.add(
+                Markdown.make({
+                  name: context.args.title ?? 'Testing',
+                  content: [
+                    `# ${context.args.title ?? 'Testing'}`,
+                    context.args.content ?? '',
+                    // TODO(burdon): Popovers not currently working.
+                    '## Here are some objects',
+                    `![Alice](${Obj.getDXN(kai)})`,
+                    `![DXOS](${Obj.getDXN(dxos)})`,
+                    '',
+                    'END',
+                    '',
+                  ].join('\n\n'),
+                }),
+              );
+
+              yield* Effect.promise(() => space.db.flush({ indexes: true }));
+            }),
+        }),
+
+        MarkdownPlugin(),
+        PreviewPlugin(),
+      ],
+    })),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    controls: { disable: true },
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    title: 'Testing',
+    content: ['This is a line with **some** formatting.'].join('\n\n'),
+  },
+};

package/src/containers/MarkdownContainer/MarkdownContainer.tsx

@@ -0,0 +1,134 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Extension } from '@codemirror/state';
+import { Atom } from '@effect-atom/atom-react';
+import React, { forwardRef, useCallback, useMemo } from 'react';
+
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { useActionRunner } from '@dxos/plugin-graph';
+import { useObject } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+import { type SelectionManager } from '@dxos/react-ui-attention';
+import { Text } from '@dxos/schema';
+
+import { MarkdownEditor, type MarkdownEditorContentProps, type MarkdownEditorRootProps } from '../../components';
+import { useLinkQuery } from '../../hooks';
+import { Markdown, MarkdownCapabilities, type MarkdownPluginState } from '../../types';
+
+export type MarkdownContainerProps = SurfaceComponentProps<
+  Markdown.Document | Text.Text,
+  {
+    id: string;
+    settings: Markdown.Settings;
+    selectionManager?: SelectionManager;
+  } & Pick<MarkdownPluginState, 'extensionProviders'> &
+    Pick<MarkdownEditorRootProps, 'viewMode' | 'onSelectObject' | 'onViewModeChange'> &
+    Pick<MarkdownEditorContentProps, 'editorStateStore'>
+>;
+
+export const MarkdownContainer = forwardRef<HTMLDivElement, MarkdownContainerProps>(
+  (
+    { role, subject: object, id, attendableId, settings, extensionProviders, onSelectObject, ...props },
+    forwardedRef,
+  ) => {
+    const db = Obj.isObject(object) ? Obj.getDatabase(object) : undefined;
+    const [docContent] = useObject(Obj.instanceOf(Markdown.Document, object) ? object.content : undefined, 'content');
+    const [textContent] = useObject(Obj.instanceOf(Text.Text, object) ? object : undefined, 'content');
+    const initialValue = docContent ?? textContent;
+
+    // Extensions from other plugins.
+    // TODO(burdon): Document MarkdownPluginState.extensionProviders
+    const otherExtensionProviders = useCapabilities(MarkdownCapabilities.Extensions);
+    const extensions = useMemo<Extension[]>(() => {
+      if (!Obj.instanceOf(Markdown.Document, object) && !Obj.instanceOf(Text.Text, object)) {
+        return [];
+      }
+
+      return [...(otherExtensionProviders ?? []), ...(extensionProviders ?? [])]
+        .flat()
+        .reduce((acc: Extension[], provider) => {
+          const extension =
+            typeof provider === 'function' ? provider({ document: object as Markdown.Document }) : provider;
+          if (extension) {
+            acc.push(extension);
+          }
+
+          return acc;
+        }, []);
+    }, [extensionProviders, otherExtensionProviders, object]);
+
+    // Toolbar actions from app graph.
+    const { graph } = useAppGraph();
+    const runAction = useActionRunner();
+    const customActions = useMemo(() => {
+      return Atom.make((get) => {
+        const actions = get(graph.actions(attendableId ?? id));
+        const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
+        const edges = nodes.map((node) => ({ source: 'root', target: node.id, relation: 'child' }));
+        return { nodes, edges };
+      });
+    }, [graph]);
+
+    // File upload.
+    const [upload] = useCapabilities(AppCapabilities.FileUploader);
+    const handleFileUpload = useMemo(() => {
+      if (!db || !upload) {
+        return undefined;
+      }
+
+      return async (file: File) => upload(db, file);
+    }, [db, upload]);
+
+    // Query for @ refs.
+    const handleLinkQuery = useLinkQuery(db);
+
+    // Open linked objects.
+    const { invokePromise } = useOperationInvoker();
+    const handleSelectObject = useCallback(
+      (targetId: string) => {
+        if (onSelectObject) {
+          onSelectObject(targetId);
+        } else {
+          void invokePromise?.(LayoutOperation.Open, {
+            subject: [targetId],
+            pivotId: attendableId,
+          });
+        }
+      },
+      [onSelectObject, invokePromise, object, id],
+    );
+
+    return (
+      <MarkdownEditor.Root
+        id={id}
+        attendableId={attendableId}
+        object={object}
+        extensions={extensions}
+        settings={settings}
+        onAction={runAction}
+        onFileUpload={handleFileUpload}
+        onLinkQuery={handleLinkQuery}
+        onSelectObject={handleSelectObject}
+        {...props}
+      >
+        <Panel.Root role={role} ref={forwardedRef}>
+          {settings.toolbar && (
+            <Panel.Toolbar asChild>
+              <MarkdownEditor.Toolbar customActions={customActions} />
+            </Panel.Toolbar>
+          )}
+          <Panel.Content>
+            <MarkdownEditor.Content initialValue={initialValue} scrollPastEnd={role === 'article'} />
+            <MarkdownEditor.Blocks />
+          </Panel.Content>
+        </Panel.Root>
+      </MarkdownEditor.Root>
+    );
+  },
+);

package/src/containers/MarkdownContainer/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { MarkdownContainer, type MarkdownContainerProps } from './MarkdownContainer';
+export { MarkdownContainer as default } from './MarkdownContainer';