@dxos/plugin-markdown 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

package/src/components/MarkdownContainer.tsx

@@ -2,256 +2,112 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { createPortal } from 'react-dom';
-
-import { Capabilities, Surface, useAppGraph, useCapabilities, usePluginManager } from '@dxos/app-framework';
-import { DXN, Filter, Obj, Query, Type } from '@dxos/echo';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { SpaceCapabilities } from '@dxos/plugin-space';
-import { useClient } from '@dxos/react-client';
-import { fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
-import { toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { type Extension } from '@codemirror/state';
+import { Atom } from '@effect-atom/atom-react';
+import React, { forwardRef, useMemo } from 'react';
+
+import { useCapabilities } from '@dxos/app-framework/ui';
+import { AppCapabilities } 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 { Layout } from '@dxos/react-ui';
 import { type SelectionManager } from '@dxos/react-ui-attention';
-import {
-  type PopoverMenuGroup,
-  type PopoverMenuItem,
-  type PreviewLinkRef,
-  type PreviewOptions,
-  insertAtCursor,
-  insertAtLineStart,
-} from '@dxos/react-ui-editor';
-import { DataType } from '@dxos/schema';
-
-import { useExtensions } from '../extensions';
-import { Markdown } from '../types';
-import { getFallbackName } from '../util';
-
-import { MarkdownEditor, type MarkdownEditorProps } from './MarkdownEditor';
-
-export type MarkdownContainerProps = Pick<
-  MarkdownEditorProps,
-  'role' | 'extensionProviders' | 'viewMode' | 'editorStateStore' | 'onViewModeChange'
-> & {
-  id: string;
-  object: Markdown.Document | DataType.Text | any;
-  settings: Markdown.Settings;
-  selectionManager?: SelectionManager;
-};
-
-export const MarkdownContainer = ({
-  id,
-  role,
-  object,
-  settings,
-  selectionManager,
-  viewMode,
-  editorStateStore,
-  onViewModeChange,
-}: MarkdownContainerProps) => {
-  const { t } = useTranslation();
-  const scrollPastEnd = role === 'article';
-  const doc = Obj.instanceOf(Markdown.Document, object) ? object : undefined;
-  const text = Obj.instanceOf(DataType.Text, object) ? object : undefined;
-  const [previewBlocks, setPreviewBlocks] = useState<{ link: PreviewLinkRef; el: HTMLElement }[]>([]);
-  const previewOptions = useMemo(
-    (): PreviewOptions => ({
-      addBlockContainer: (link, el) => {
-        setPreviewBlocks((prev) => [...prev, { link, el }]);
-      },
-      removeBlockContainer: (link) => {
-        setPreviewBlocks((prev) => prev.filter(({ link: prevLink }) => prevLink.ref !== link.ref));
-      },
-    }),
-    [],
-  );
-  const extensions = useExtensions({
-    document: doc,
-    text,
-    id,
-    settings,
-    selectionManager,
-    viewMode,
-    editorStateStore,
-    previewOptions,
-  });
-
-  // TODO(wittjosiah): Factor out.
-  const manager = usePluginManager();
-  const resolve = useCallback(
-    (typename: string) =>
-      manager.context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {},
-    [manager],
-  );
-  const space = getSpace(object);
-  const objectForms = useCapabilities(SpaceCapabilities.ObjectForm);
-  const schemaWhiteList = useCapabilities(ClientCapabilities.SchemaWhiteList);
-  const filter = useMemo(
-    () =>
-      Filter.or(
-        ...objectForms.map((form) => Filter.type(form.objectSchema)),
-        ...schemaWhiteList.flat().map((schema) => Filter.typename(Type.getTypename(schema))),
-      ),
-    [objectForms, schemaWhiteList],
-  );
-
-  const handleLinkQuery = useCallback(
-    async (query?: string): Promise<PopoverMenuGroup[]> => {
-      const name = query?.startsWith('@') ? query.slice(1).toLowerCase() : (query?.toLowerCase() ?? '');
-      const results = await space?.db.query(Query.select(filter)).run();
-      // TODO(wittjosiah): Use `Obj.Any` type.
-      const getLabel = (object: any) => {
-        const label = Obj.getLabel(object);
-        if (label) {
-          return label;
-        }
-
-        // TODO(wittjosiah): Remove metadata labels.
-        const type = Obj.getTypename(object)!;
-        const metadata = resolve(type);
-        return metadata.label?.(object) || ['object name placeholder', { ns: type, default: 'New object' }];
-      };
-      const items =
-        results?.objects
-          .filter((object) => toLocalizedString(getLabel(object), t).toLowerCase().includes(name))
-          // TODO(wittjosiah): Remove `any` type.
-          .map((object: any): PopoverMenuItem => {
-            const metadata = resolve(Obj.getTypename(object)!);
-            const label = toLocalizedString(getLabel(object), t);
-            return {
-              id: object.id,
-              label,
-              icon: metadata.icon,
-              onSelect: (view, head) => {
-                const link = `[${label}](${Obj.getDXN(object)})`;
-                if (query?.startsWith('@')) {
-                  insertAtLineStart(view, head, `!${link}\n`);
-                } else {
-                  insertAtCursor(view, head, `${link} `);
-                }
-              },
-            };
-          }) ?? [];
-      return [{ id: 'echo', items }];
-    },
-    [filter, resolve, space],
-  );
-
-  // TODO(burdon): Reconcile variants.
-  const editor = doc ? (
-    <DocumentEditor
-      id={fullyQualifiedId(object)}
-      role={role}
-      document={doc}
-      extensions={extensions}
-      viewMode={viewMode}
-      settings={settings}
-      scrollPastEnd={scrollPastEnd}
-      onViewModeChange={onViewModeChange}
-      onLinkQuery={space ? handleLinkQuery : undefined}
-    />
-  ) : text ? (
-    <MarkdownEditor
-      id={id}
-      role={role}
-      initialValue={text.content}
-      extensions={extensions}
-      viewMode={viewMode}
-      toolbar={settings.toolbar}
-      inputMode={settings.editorInputMode}
-      scrollPastEnd={scrollPastEnd}
-      onViewModeChange={onViewModeChange}
-      onLinkQuery={space ? handleLinkQuery : undefined}
-    />
-  ) : (
-    <MarkdownEditor
-      id={id}
-      role={role}
-      initialValue={object.text}
-      extensions={extensions}
-      viewMode={viewMode}
-      toolbar={settings.toolbar}
-      inputMode={settings.editorInputMode}
-      scrollPastEnd={scrollPastEnd}
-      onViewModeChange={onViewModeChange}
-      onLinkQuery={space ? handleLinkQuery : undefined}
-    />
-  );
-
-  return (
-    <>
-      {editor}
-      {previewBlocks.map(({ link, el }) => (
-        <PreviewBlock key={link.ref} link={link} el={el} />
-      ))}
-    </>
-  );
-};
-
-// TODO(wittjosiah): This shouldn't be "card" but "block".
-//   It's not a preview card but an interactive embedded object.
-const PreviewBlock = ({ link, el }: { link: PreviewLinkRef; el: HTMLElement }) => {
-  const client = useClient();
-  const dxn = DXN.parse(link.ref);
-  const subject = client.graph.ref(dxn).target;
-  const data = useMemo(() => ({ subject }), [subject]);
-
-  return createPortal(<Surface role='card--transclusion' data={data} limit={1} />, el);
-};
-
-type DocumentEditorProps = Omit<MarkdownContainerProps, 'object' | 'extensionProviders' | 'editorStateStore'> &
-  Pick<MarkdownEditorProps, 'id' | 'scrollPastEnd' | 'extensions' | 'onLinkQuery'> & {
-    document: Markdown.Document;
-  };
-
-export const DocumentEditor = ({ id, document: doc, settings, viewMode, ...props }: DocumentEditorProps) => {
-  const space = getSpace(doc);
-
-  // Migrate gradually to `fallbackName`.
-  useEffect(() => {
-    if (typeof doc.fallbackName === 'string') {
-      return;
-    }
-
-    const fallbackName = doc.content?.target?.content ? getFallbackName(doc.content.target.content) : undefined;
-    if (fallbackName) {
-      doc.fallbackName = fallbackName;
-    }
-  }, [doc, doc.content]);
-
-  // File dragging.
-  const [upload] = useCapabilities(Capabilities.FileUploader);
-  const handleFileUpload = useMemo(() => {
-    if (space === undefined || upload === undefined) {
-      return undefined;
-    }
-
-    // TODO(burdon): Re-order props: space, file.
-    return async (file: File) => upload!(file, space);
-  }, [space, upload]);
-
-  const { graph } = useAppGraph();
-  const customActions = useMemo(() => {
-    return Rx.make((get) => {
-      const actions = get(graph.actions(id));
-      const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
-      return { nodes, edges: nodes.map((node) => ({ source: 'root', target: node.id })) };
-    });
-  }, [graph]);
-
-  return (
-    <MarkdownEditor
-      id={id}
-      initialValue={doc.content?.target?.content}
-      viewMode={viewMode}
-      toolbar={settings.toolbar}
-      customActions={customActions}
-      inputMode={settings.editorInputMode}
-      onFileUpload={handleFileUpload}
-      {...props}
-    />
-  );
-};
+import { Text } from '@dxos/schema';
+
+import { useLinkQuery } from '../hooks';
+import { Markdown, MarkdownCapabilities, type MarkdownPluginState } from '../types';
+
+import { MarkdownEditor, type MarkdownEditorContentProps, type MarkdownEditorRootProps } from './MarkdownEditor';
+
+export type MarkdownContainerProps = SurfaceComponentProps<
+  Markdown.Document | Text.Text,
+  {
+    id: string;
+    settings: Markdown.Settings;
+    selectionManager?: SelectionManager;
+  } & Pick<MarkdownEditorRootProps, 'viewMode' | 'onViewModeChange'> &
+    Pick<MarkdownEditorContentProps, 'editorStateStore'> &
+    Pick<MarkdownPluginState, 'extensionProviders'>
+>;
+
+export const MarkdownContainer = forwardRef<HTMLDivElement, MarkdownContainerProps>(
+  ({ role, subject: object, id, settings, extensionProviders, ...props }, forwardedRef) => {
+    const db = Obj.isObject(object) ? Obj.getDatabase(object) : undefined;
+    const attendableId = Obj.instanceOf(Markdown.Document, object) ? Obj.getDXN(object).toString() : 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(id));
+        const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
+        const edges = nodes.map((node) => ({ source: 'root', target: node.id }));
+        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);
+
+    return (
+      <Layout.Main toolbar={settings.toolbar} ref={forwardedRef}>
+        <MarkdownEditor.Root
+          id={attendableId ?? id}
+          object={object}
+          extensions={extensions}
+          settings={settings}
+          onAction={runAction}
+          onFileUpload={handleFileUpload}
+          onLinkQuery={handleLinkQuery}
+          {...props}
+        >
+          {settings.toolbar && (
+            <MarkdownEditor.Toolbar id={attendableId ?? id} role={role} customActions={customActions} />
+          )}
+          <MarkdownEditor.Content initialValue={initialValue} scrollPastEnd={role === 'article'} />
+          <MarkdownEditor.Blocks />
+        </MarkdownEditor.Root>
+      </Layout.Main>
+    );
+  },
+);
 
 export default MarkdownContainer;

package/src/components/MarkdownEditor/FileUpload.tsx

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+import React, { forwardRef, useEffect, useImperativeHandle } from 'react';
+import { createPortal } from 'react-dom';
+import { useDropzone } from 'react-dropzone';
+
+import { type FileInfo } from '@dxos/app-toolkit';
+import { addLink } from '@dxos/ui-editor';
+
+export const IMAGE_FILES = ['.jpg', '.jpeg', '.png', '.gif'];
+
+export type FileUploadAction = () => void;
+
+export type FileUploadProps = {
+  editorView?: EditorView;
+  onFileUpload?: (file: File) => Promise<FileInfo | undefined>;
+};
+
+// TODO(burdon): Factor out.
+// TODO(burdon): Move to root? (support drag into document via dropzone).
+export const FileUpload = forwardRef<FileUploadAction, FileUploadProps>(
+  ({ editorView, onFileUpload }, forwardedRef) => {
+    // https://react-dropzone.js.org
+    const { acceptedFiles, open, inputRef } = useDropzone({
+      disabled: !onFileUpload,
+      multiple: false,
+      noDrag: true,
+      accept: {
+        'image/*': IMAGE_FILES,
+      },
+    });
+
+    useImperativeHandle(forwardedRef, () => open, []);
+
+    useEffect(() => {
+      if (editorView && acceptedFiles.length && onFileUpload) {
+        requestAnimationFrame(async () => {
+          // NOTE: Clone file since react-dropzone patches in a non-standard `path` property, which confuses IPFS.
+          const f = acceptedFiles[0];
+          const file = new File([f], f.name, {
+            type: f.type,
+            lastModified: f.lastModified,
+          });
+
+          // TODO(burdon): Factor out.
+          const info = await onFileUpload(file);
+          if (info) {
+            addLink({ url: info.url, image: true })(editorView);
+          }
+        });
+      }
+    }, [editorView, acceptedFiles, onFileUpload]);
+
+    if (!onFileUpload) {
+      return null;
+    }
+
+    return <>{createPortal(<input ref={inputRef} />, document.body)} </>;
+  },
+);

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

@@ -3,63 +3,81 @@
 //
 
 import { type Meta, type StoryObj } from '@storybook/react-vite';
-import React, { useMemo } from 'react';
+import * as Effect from 'effect/Effect';
+import React from 'react';
 
-import { IntentPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
-import { createDocAccessor, createObject } from '@dxos/react-client/echo';
-import { withTheme } from '@dxos/react-ui/testing';
-import { withAttention } from '@dxos/react-ui-attention/testing';
-import { automerge, translations as editorTranslations } from '@dxos/react-ui-editor';
-import { Stack, StackItem } from '@dxos/react-ui-stack';
+import { Filter, Obj } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { corePlugins } from '@dxos/plugin-testing';
+import { useQuery, useSpace } from '@dxos/react-client/echo';
+import { Layout } from '@dxos/react-ui';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { useAttentionAttributes } from '@dxos/react-ui-attention';
+import { translations as editorTranslations } from '@dxos/react-ui-editor';
 
 import { translations } from '../../translations';
+import { Markdown } from '../../types';
 
-import { MarkdownEditor, type MarkdownEditorProps } from './MarkdownEditor';
+import { MarkdownEditor, type MarkdownEditorRootProps } from './MarkdownEditor';
 
 const content = Array.from({ length: 100 }, (_, i) => `Line ${i + 1}`).join('\n');
 
-type StoryProps = MarkdownEditorProps & {
-  content?: string;
-  toolbar?: boolean;
-};
+type StoryProps = Omit<MarkdownEditorRootProps, 'id' | 'extensions'>;
+
+const DefaultStory = (props: StoryProps) => {
+  const space = useSpace();
+  const [doc] = useQuery(space?.db, Filter.type(Markdown.Document));
+  const id = doc && Obj.getDXN(doc).toString();
+  const attentionAttrs = useAttentionAttributes(id);
+  if (!id) {
+    return null;
+  }
 
-const DefaultStory = ({ content = '# Test', toolbar }: StoryProps) => {
-  const doc = useMemo(() => createObject({ content }), [content]); // TODO(burdon): Remove dependency on createObject.
-  const extensions = useMemo(() => [automerge(createDocAccessor(doc, ['content']))], [doc]);
   return (
-    <Stack orientation='horizontal' rail={false}>
-      <StackItem.Root item={{ id: 'story' }}>
-        <MarkdownEditor id='test' initialValue={doc.content} extensions={extensions} toolbar={toolbar} />
-      </StackItem.Root>
-    </Stack>
+    <div className='contents' {...attentionAttrs}>
+      <Layout.Main toolbar>
+        <MarkdownEditor.Root id={id} object={doc} {...props}>
+          <MarkdownEditor.Toolbar id={id} />
+          <MarkdownEditor.Content />
+        </MarkdownEditor.Root>
+      </Layout.Main>
+    </div>
   );
 };
 
-const meta = {
+const meta: Meta<typeof DefaultStory> = {
   title: 'plugins/plugin-markdown/MarkdownEditor',
-  component: MarkdownEditor as any,
-  render: DefaultStory,
-  decorators: [withTheme, withPluginManager({ plugins: [IntentPlugin()] }), withAttention],
+  component: DefaultStory,
+  render: DefaultStory as any,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Markdown.Document],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* Effect.promise(() => client.halo.createIdentity());
+              yield* Effect.promise(() => client.spaces.waitUntilReady());
+              const space = client.spaces.default;
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              space.db.add(Markdown.make({ content }));
+            }),
+        }),
+      ],
+    }),
+  ],
   parameters: {
-    layout: 'fullscreen',
     translations: [...translations, ...editorTranslations],
   },
-} satisfies Meta<typeof DefaultStory>;
+};
 
 export default meta;
 
 type Story = StoryObj<typeof meta>;
 
-export const Default: Story = {
-  args: {
-    content,
-  },
-};
-
-export const WithToolbar: Story = {
-  args: {
-    toolbar: true,
-    content,
-  },
-};
+export const Default: Story = {};