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

package/src/{components → containers}/MarkdownCard/MarkdownCard.tsx

@@ -5,60 +5,53 @@
 import React, { useMemo } from 'react';
 
 import { Obj } from '@dxos/echo';
-import { useTranslation } from '@dxos/react-ui';
-import { Card } from '@dxos/react-ui-mosaic';
+import { Card, useTranslation } from '@dxos/react-ui';
 import { Text } from '@dxos/schema';
 
-import { meta } from '../../meta';
-import { Markdown } from '../../types';
-import { getContentSnippet, getFallbackName } from '../../util';
-import { MarkdownEditor } from '../MarkdownEditor';
+import { MarkdownEditor } from '#components';
+import { meta } from '#meta';
+import { Markdown } from '#types';
+import { getContentSnippet } from '../../util';
+
+import { snippet as snippetExtension } from './snippet';
 
 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 extensions = useMemo(() => [snippetExtension({ height: 240, scale: 0.8 })], []);
   const info = getInfo(subject);
 
   return (
     <Card.Content>
       {snippet && (
-        <Card.Row className='max-h-[300px] overflow-hidden'>
-          <MarkdownEditor.Root id={subject.id} viewMode='readonly'>
-            <MarkdownEditor.Content initialValue={snippet} slots={{}} classNames='!bg-transparent' />
+        <Card.Section className='px-1'>
+          <MarkdownEditor.Root id={subject.id} viewMode='readonly' extensions={extensions}>
+            <MarkdownEditor.Content initialValue={snippet} slots={{ content: { className: 'm-0' } }} />
           </MarkdownEditor.Root>
-        </Card.Row>
+        </Card.Section>
       )}
-      <Card.Row>
-        <Card.Text classNames='text-xs text-description'>
-          {info.words} {t('words label', { count: info.words })}
+      <Card.Section>
+        <Card.Text classNames='px-1.5 text-xs text-description'>
+          {info.words} {t('words.label', { count: info.words })}
         </Card.Text>
-      </Card.Row>
+      </Card.Section>
     </Card.Content>
   );
 };
 
-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 };
-};
+const MAX_LINES = 5;
 
-// TODO(burdon): Factor out.
-const getTitle = (subject: Markdown.Document | Text.Text, fallback: string) => {
+const getSnippet = (subject: Markdown.Document | Text.Text, fallback?: string) => {
   if (Obj.instanceOf(Markdown.Document, subject)) {
-    const title = Obj.getLabel(subject);
-    return title ?? getFallbackName(subject.content?.target?.content ?? fallback);
+    return Obj.getDescription(subject) || getContentSnippet(subject.content?.target?.content ?? fallback, MAX_LINES);
   } else if (Obj.instanceOf(Text.Text, subject)) {
-    return getFallbackName(subject.content);
+    return getContentSnippet(subject.content ?? fallback, MAX_LINES);
   }
 };
 
-// TODO(burdon): Factor out.
-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);
-  } else if (Obj.instanceOf(Text.Text, subject)) {
-    return getContentSnippet(subject.content ?? fallback);
-  }
+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/{components → containers}/MarkdownCard/index.ts

@@ -4,6 +4,4 @@
 
 import { MarkdownCard } from './MarkdownCard';
 
-export * from './MarkdownCard';
-
 export default MarkdownCard;

package/src/containers/MarkdownCard/snippet.ts

@@ -0,0 +1,75 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type PluginValue, EditorView, ViewPlugin, type ViewUpdate } from '@codemirror/view';
+
+export type SnippetOptions = {
+  /** Maximum height of the editor in pixels. Content is clipped to whole lines within this height. */
+  height: number;
+  /** Zoom factor applied to the editor (e.g. 0.5 renders at 50%). @default 1 */
+  scale?: number;
+};
+
+/**
+ * CodeMirror extension for rendering a non-scrollable snippet of editor content.
+ * Constrains the editor to the given height, clips to whole line boundaries,
+ * and disables scrolling entirely.
+ * Uses requestMeasure to read post-layout heights and lineBlockAtHeight to handle
+ * varying line heights from headings and other decorated blocks.
+ */
+export const snippet = ({ height, scale = 1 }: SnippetOptions) => {
+  // Internal height is divided by scale so the visible area matches the requested height.
+  const internalHeight = Math.round(height / scale);
+
+  const clipPlugin = ViewPlugin.fromClass(
+    class SnippetPlugin implements PluginValue {
+      private clipHeight = 0;
+
+      update(update: ViewUpdate) {
+        update.view.requestMeasure({
+          // key dedupliactes concurrent requests within the same animation frame.
+          key: this,
+          read: (view) => {
+            const containerHeight = view.dom.clientHeight;
+            if (containerHeight === 0) {
+              return 0;
+            }
+            // Find the block (line) at the very bottom of the visible area.
+            const block = view.lineBlockAtHeight(containerHeight - 1);
+            // If the block overflows the container, clip at the block's top edge.
+            return block.top + block.height > containerHeight ? block.top : containerHeight;
+          },
+          write: (clipHeight, view) => {
+            if (clipHeight > 0 && clipHeight !== this.clipHeight) {
+              this.clipHeight = clipHeight;
+              view.dom.style.maxHeight = `${clipHeight}px`;
+            }
+          },
+        });
+      }
+    },
+  );
+
+  return [
+    clipPlugin,
+    EditorView.theme({
+      '&': {
+        maxHeight: `${internalHeight}px`,
+        overflow: 'hidden',
+        ...(scale !== 1 && { zoom: `${scale}` }),
+      },
+      '.cm-content': {
+        whiteSpace: 'pre',
+        margin: '0',
+        padding: '0',
+      },
+      '.cm-line': {
+        padding: '0',
+      },
+      '.cm-scroller': {
+        overflow: 'hidden !important',
+      },
+    }),
+  ];
+};

package/src/{components → containers/MarkdownContainer}/MarkdownContainer.stories.tsx

@@ -6,30 +6,42 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 import * as Effect from 'effect/Effect';
 import React, { useMemo } from 'react';
 
-import { Common } from '@dxos/app-framework';
-import { Surface, useOperationInvoker } from '@dxos/app-framework/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 { initializeIdentity } from '@dxos/plugin-client/testing';
 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 { withLayout } 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 } from '../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();
@@ -40,45 +52,43 @@ const DefaultStory = () => {
 
   useAsyncEffect(async () => {
     if (space) {
-      await invokePromise(Common.LayoutOperation.SwitchWorkspace, { subject: space.id });
+      await invokePromise(LayoutOperation.SwitchWorkspace, { subject: space.id });
     }
   }, [space, invokePromise]);
 
   return (
     <div className='contents' {...attentionAttrs}>
-      <Surface role='article' data={data} limit={1} />
+      <Surface.Surface role='article' data={data} limit={1} />
     </div>
   );
 };
 
 const meta = {
-  title: 'plugins/plugin-markdown/MarkdownContainer',
+  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 { personalSpace } = yield* initializeIdentity(client);
 
-              const space = client.spaces.default;
-              const createObjects = createObjectFactory(space.db, generator);
+              const createObjects = createObjectFactory(personalSpace.db, generator);
               yield* Effect.promise(() => createObjects([{ type: Organization.Organization, count: 10 }]));
 
-              const queue = space.queues.create();
+              const queue = personalSpace.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(
+              personalSpace.db.add(
                 Markdown.make({
                   name: context.args.title ?? 'Testing',
                   content: [
@@ -95,7 +105,7 @@ const meta = {
                 }),
               );
 
-              yield* Effect.promise(() => space.db.flush({ indexes: true }));
+              yield* Effect.promise(() => personalSpace.db.flush({ indexes: true }));
             }),
         }),
 

package/src/{components → containers/MarkdownContainer}/MarkdownContainer.tsx

@@ -4,43 +4,45 @@
 
 import { type Extension } from '@codemirror/state';
 import { Atom } from '@effect-atom/atom-react';
-import React, { forwardRef, useMemo } from 'react';
+import React, { forwardRef, useCallback, useMemo } from 'react';
 
-import { Common } from '@dxos/app-framework';
-import { type SurfaceComponentProps, useAppGraph, useCapabilities } from '@dxos/app-framework/react';
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { type ObjectSurfaceProps } 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 { Layout } from '@dxos/react-ui-mosaic';
 import { Text } from '@dxos/schema';
 
-import { useLinkQuery } from '../hooks';
-import { Markdown, MarkdownCapabilities, type MarkdownPluginState } from '../types';
+import { MarkdownEditor, type MarkdownEditorContentProps, type MarkdownEditorRootProps } from '#components';
+import { useLinkQuery } from '#hooks';
+import { Markdown, MarkdownCapabilities, type MarkdownPluginState } from '#types';
 
-import { MarkdownEditor, type MarkdownEditorContentProps, type MarkdownEditorRootProps } from './MarkdownEditor';
-
-export type MarkdownContainerProps = SurfaceComponentProps<
+export type MarkdownContainerProps = ObjectSurfaceProps<
   Markdown.Document | Text.Text,
   {
     id: string;
     settings: Markdown.Settings;
     selectionManager?: SelectionManager;
-  } & Pick<MarkdownEditorRootProps, 'viewMode' | 'onViewModeChange'> &
-    Pick<MarkdownEditorContentProps, 'editorStateStore'> &
-    Pick<MarkdownPluginState, 'extensionProviders'>
+  } & Pick<MarkdownPluginState, 'extensionProviders'> &
+    Pick<MarkdownEditorRootProps, 'viewMode' | 'onSelectObject' | 'onViewModeChange'> &
+    Pick<MarkdownEditorContentProps, 'editorStateStore'>
 >;
 
 export const MarkdownContainer = forwardRef<HTMLDivElement, MarkdownContainerProps>(
-  ({ role, subject: object, id, settings, extensionProviders, ...props }, forwardedRef) => {
+  (
+    { role, subject: object, id, attendableId, settings, extensionProviders, onSelectObject, ...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)) {
@@ -65,15 +67,15 @@ export const MarkdownContainer = forwardRef<HTMLDivElement, MarkdownContainerPro
     const runAction = useActionRunner();
     const customActions = useMemo(() => {
       return Atom.make((get) => {
-        const actions = get(graph.actions(id));
+        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 }));
+        const edges = nodes.map((node) => ({ source: 'root', target: node.id, relation: 'child' }));
         return { nodes, edges };
       });
     }, [graph]);
 
     // File upload.
-    const [upload] = useCapabilities(Common.Capability.FileUploader);
+    const [upload] = useCapabilities(AppCapabilities.FileUploader);
     const handleFileUpload = useMemo(() => {
       if (!db || !upload) {
         return undefined;
@@ -85,27 +87,48 @@ export const MarkdownContainer = forwardRef<HTMLDivElement, MarkdownContainerPro
     // 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 (
-      <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}
-        >
+      <MarkdownEditor.Root
+        id={id}
+        attendableId={attendableId}
+        object={object}
+        compact={role !== 'article'}
+        extensions={extensions}
+        settings={settings}
+        onAction={runAction}
+        onFileUpload={handleFileUpload}
+        onLinkQuery={handleLinkQuery}
+        onSelectObject={handleSelectObject}
+        {...props}
+      >
+        <Panel.Root role={role} ref={forwardedRef}>
           {settings.toolbar && (
-            <MarkdownEditor.Toolbar id={attendableId ?? id} role={role} customActions={customActions} />
+            <Panel.Toolbar classNames='bg-toolbar-surface'>
+              <MarkdownEditor.Toolbar classNames='dx-document' customActions={customActions} />
+            </Panel.Toolbar>
           )}
-          <MarkdownEditor.Content initialValue={initialValue} scrollPastEnd={role === 'article'} />
-          <MarkdownEditor.Blocks />
-        </MarkdownEditor.Root>
-      </Layout.Main>
+          <Panel.Content>
+            <MarkdownEditor.Content initialValue={initialValue} />
+            <MarkdownEditor.Blocks />
+          </Panel.Content>
+        </Panel.Root>
+      </MarkdownEditor.Root>
     );
   },
 );
-
-export default MarkdownContainer;

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';

package/src/containers/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export type { MarkdownContainerProps } from './MarkdownContainer';
+
+export const MarkdownCard: ComponentType<any> = lazy(() => import('./MarkdownCard'));
+export const MarkdownContainer: ComponentType<any> = lazy(() => import('./MarkdownContainer'));

package/src/hooks/index.ts

@@ -5,4 +5,3 @@
 export * from './useEditorMenuOptions';
 export * from './useExtensions';
 export * from './useLinkQuery';
-export * from './useSelectCurrentThread';

package/src/hooks/useEditorMenuOptions.ts

@@ -15,7 +15,7 @@ import {
 } from '@dxos/react-ui-editor';
 import { Domino } from '@dxos/ui';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
 export type UseEditorMenuOptionsProps = {
   editorView?: EditorView;
@@ -56,7 +56,7 @@ export const useEditorMenuOptions = ({
       content: () => {
         const pressEl = Domino.of('span').text('Press');
         const triggerEls = trigger.map((text) =>
-          Domino.of('span').classNames('mx-1 pli-1.5 pt-[1px] pb-[2px] border border-separator rounded-sm').text(text),
+          Domino.of('span').classNames('mx-1 px-1.5 pt-[1px] pb-[2px] border border-separator rounded-xs').text(text),
         );
         const forCommandsEl = Domino.of('span').text('for commands.');
         return Domino.of('div').children(pressEl, ...triggerEls, forCommandsEl).root;