@dxos/plugin-markdown 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/components/MarkdownSettings/MarkdownSettings.tsx

@@ -4,119 +4,135 @@
 
 import React from 'react';
 
+import { type AppSurface } from '@dxos/app-toolkit/ui';
 import { Input, Select, useTranslation } from '@dxos/react-ui';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
+import { Settings as SettingsForm } from '@dxos/react-ui-form';
 import { type EditorInputMode, EditorInputModes, type EditorViewMode, EditorViewModes } from '@dxos/ui-editor';
 
-import { meta } from '../../meta';
-import { type Markdown } from '../../types';
+import { meta } from '#meta';
+import { type Markdown } from '#types';
 
-export type MarkdownSettingsComponentProps = {
-  settings: Markdown.Settings;
-  onSettingsChange: (fn: (current: Markdown.Settings) => Markdown.Settings) => void;
-};
+export type MarkdownSettingsProps = AppSurface.SettingsArticleProps<Markdown.Settings>;
 
-export const MarkdownSettings = ({ settings, onSettingsChange }: MarkdownSettingsComponentProps) => {
+export const MarkdownSettings = ({ settings, onSettingsChange }: MarkdownSettingsProps) => {
   const { t } = useTranslation(meta.id);
 
   // TODO(wittjosiah): Add skill test confirmation for entering vim mode.
   return (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <ControlGroup>
-          <ControlItemInput title={t('default view mode label')}>
-            <Select.Root
-              value={settings.defaultViewMode}
-              onValueChange={(value) => {
-                onSettingsChange((s) => ({ ...s, defaultViewMode: value as EditorViewMode }));
-              }}
-            >
-              <Select.TriggerButton />
-              <Select.Portal>
-                <Select.Content>
-                  <Select.Viewport>
-                    {EditorViewModes.map((mode) => (
-                      <Select.Option key={mode} value={mode}>
-                        {t(`${mode} mode label`, { ns: 'react-ui-editor' })}
-                      </Select.Option>
-                    ))}
-                  </Select.Viewport>
-                  <Select.Arrow />
-                </Select.Content>
-              </Select.Portal>
-            </Select.Root>
-          </ControlItemInput>
-
-          <ControlItemInput title={t('editor input mode label')}>
-            <Select.Root
-              value={settings.editorInputMode ?? 'default'}
-              onValueChange={(value) => {
-                onSettingsChange((s) => ({ ...s, editorInputMode: value as EditorInputMode }));
-              }}
-            >
-              <Select.TriggerButton placeholder={t('select editor input mode placeholder')} />
-              <Select.Portal>
-                <Select.Content>
-                  <Select.Viewport>
-                    {EditorInputModes.map((mode) => (
-                      <Select.Option key={mode} value={mode}>
-                        {t(`settings editor input mode ${mode} label`)}
-                      </Select.Option>
-                    ))}
-                  </Select.Viewport>
-                  <Select.Arrow />
-                </Select.Content>
-              </Select.Portal>
-            </Select.Root>
-          </ControlItemInput>
+    <SettingsForm.Viewport>
+      <SettingsForm.Section title={t('settings.title', { ns: meta.id })}>
+        <SettingsForm.Item title={t('default-view-mode.label')} description={t('default-view-mode.description')}>
+          <Select.Root
+            disabled={!onSettingsChange}
+            value={settings.defaultViewMode}
+            onValueChange={(value) => {
+              onSettingsChange?.((s) => ({ ...s, defaultViewMode: value as EditorViewMode }));
+            }}
+          >
+            <Select.TriggerButton disabled={!onSettingsChange} />
+            <Select.Portal>
+              <Select.Content>
+                <Select.Viewport>
+                  {EditorViewModes.map((mode) => (
+                    <Select.Option key={mode} value={mode}>
+                      {t(`view-mode.${mode}.label`, { ns: '@dxos/react-ui-editor' })}
+                    </Select.Option>
+                  ))}
+                </Select.Viewport>
+                <Select.Arrow />
+              </Select.Content>
+            </Select.Portal>
+          </Select.Root>
+        </SettingsForm.Item>
 
-          <ControlItemInput title={t('settings toolbar label')}>
-            <Input.Switch
-              checked={settings.toolbar}
-              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, toolbar: !!checked }))}
+        <SettingsForm.Item title={t('editor-input-mode.label')} description={t('editor-input-mode.description')}>
+          <Select.Root
+            disabled={!onSettingsChange}
+            value={settings.editorInputMode ?? 'default'}
+            onValueChange={(value) => {
+              onSettingsChange?.((s) => ({ ...s, editorInputMode: value as EditorInputMode }));
+            }}
+          >
+            <Select.TriggerButton
+              disabled={!onSettingsChange}
+              placeholder={t('select-editor-input-mode.placeholder')}
             />
-          </ControlItemInput>
+            <Select.Portal>
+              <Select.Content>
+                <Select.Viewport>
+                  {EditorInputModes.map((mode) => (
+                    <Select.Option key={mode} value={mode}>
+                      {t(`settings.editor-input-mode.${mode}.label`)}
+                    </Select.Option>
+                  ))}
+                </Select.Viewport>
+                <Select.Arrow />
+              </Select.Content>
+            </Select.Portal>
+          </Select.Root>
+        </SettingsForm.Item>
 
-          <ControlItemInput title={t('settings numbered headings label')}>
-            <Input.Switch
-              checked={settings.numberedHeadings}
-              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, numberedHeadings: !!checked }))}
-            />
-          </ControlItemInput>
+        <SettingsForm.Item title={t('settings.toolbar.label')} description={t('settings.toolbar.description')}>
+          <Input.Switch
+            disabled={!onSettingsChange}
+            checked={settings.toolbar}
+            onCheckedChange={(checked) => onSettingsChange?.((s) => ({ ...s, toolbar: !!checked }))}
+          />
+        </SettingsForm.Item>
 
-          <ControlItemInput title={t('settings folding label')}>
-            <Input.Switch
-              checked={settings.folding}
-              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, folding: !!checked }))}
-            />
-          </ControlItemInput>
+        <SettingsForm.Item
+          title={t('settings.numbered-headings.label')}
+          description={t('settings.numbered-headings.description')}
+        >
+          <Input.Switch
+            disabled={!onSettingsChange}
+            checked={settings.numberedHeadings}
+            onCheckedChange={(checked) => onSettingsChange?.((s) => ({ ...s, numberedHeadings: !!checked }))}
+          />
+        </SettingsForm.Item>
 
-          <ControlItemInput title={t('settings experimental label')}>
-            <Input.Switch
-              checked={settings.experimental}
-              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, experimental: !!checked }))}
-            />
-          </ControlItemInput>
+        <SettingsForm.Item title={t('settings.folding.label')} description={t('settings.folding.description')}>
+          <Input.Switch
+            disabled={!onSettingsChange}
+            checked={settings.folding}
+            onCheckedChange={(checked) => onSettingsChange?.((s) => ({ ...s, folding: !!checked }))}
+          />
+        </SettingsForm.Item>
 
-          <ControlItemInput title={t('settings debug label')}>
-            <Input.Switch
-              checked={settings.debug}
-              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, debug: !!checked }))}
-            />
-          </ControlItemInput>
+        <SettingsForm.Item
+          title={t('settings.experimental.label')}
+          description={t('settings.experimental.description')}
+        >
+          <Input.Switch
+            disabled={!onSettingsChange}
+            checked={settings.experimental}
+            onCheckedChange={(checked) => onSettingsChange?.((s) => ({ ...s, experimental: !!checked }))}
+          />
+        </SettingsForm.Item>
 
-          {settings.debug && (
-            <ControlItemInput title={t('settings debug textarea label', { ns: meta.id })}>
-              <Input.TextArea
-                rows={5}
-                value={settings.typewriter}
-                onChange={({ target: { value } }) => onSettingsChange((s) => ({ ...s, typewriter: value }))}
-                placeholder={t('settings debug placeholder')}
-              />
-            </ControlItemInput>
-          )}
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
+        <SettingsForm.Item title={t('settings.debug.label')} description={t('settings.debug.description')}>
+          <Input.Switch
+            disabled={!onSettingsChange}
+            checked={settings.debug}
+            onCheckedChange={(checked) => onSettingsChange?.((s) => ({ ...s, debug: !!checked }))}
+          />
+        </SettingsForm.Item>
+
+        {settings.debug && (
+          <SettingsForm.Item
+            title={t('settings.debug-typewriter.label', { ns: meta.id })}
+            description={t('settings.debug-typewriter.description')}
+          >
+            <Input.TextArea
+              disabled={!onSettingsChange}
+              rows={5}
+              value={settings.typewriter}
+              onChange={({ target: { value } }) => onSettingsChange?.((s) => ({ ...s, typewriter: value }))}
+              placeholder={t('settings.debug-typewriter.placeholder')}
+            />
+          </SettingsForm.Item>
+        )}
+      </SettingsForm.Section>
+    </SettingsForm.Viewport>
   );
 };

package/src/components/MarkdownSettings/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './MarkdownSettings';
+export { MarkdownSettings as default } from './MarkdownSettings';

package/src/components/index.ts

@@ -1,17 +1,9 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-import { type LazyExoticComponent, lazy } from 'react';
+import { type ComponentType, lazy } from 'react';
 
-import { type MarkdownCard as MarkdownCardType } from './MarkdownCard';
-import { type MarkdownContainer as MarkdownContainerType } from './MarkdownContainer';
+export * from './MarkdownEditor';
 
-export * from './MarkdownCard';
-export * from './MarkdownContainer';
-export * from './MarkdownSettings';
-
-export const MarkdownCard: LazyExoticComponent<typeof MarkdownCardType> = lazy(() => import('./MarkdownCard'));
-export const MarkdownContainer: LazyExoticComponent<typeof MarkdownContainerType> = lazy(
-  () => import('./MarkdownContainer'),
-);
+export const MarkdownSettings: ComponentType<any> = lazy(() => import('./MarkdownSettings'));

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

@@ -5,43 +5,52 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useMemo } from 'react';
 
-import { OperationPlugin } from '@dxos/app-framework';
+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 { withTheme } from '@dxos/react-ui/testing';
+import { random } from '@dxos/random';
+import { Card } from '@dxos/react-ui';
 import { CardContainer } from '@dxos/react-ui-mosaic/testing';
+import { withTheme } from '@dxos/react-ui/testing';
 
 import { translations } from '../../translations';
-
 import { MarkdownCard, type MarkdownCardProps } from './MarkdownCard';
 
-faker.seed(1234);
+random.seed(1234);
 
-// TODO(wittjosiah): ECHO objects don't work when passed via Storybook args.
 const MarkdownCardStory = ({ ...args }: Omit<MarkdownCardProps, 'subject'>) => {
   const subject = useMemo(
     () =>
       Markdown.make({
-        name: faker.lorem.words(3),
-        content: faker.lorem.paragraphs(3),
+        name: random.lorem.words(3),
+        content: random.lorem.paragraphs(5),
       }),
     [],
   );
+
   return (
     <CardContainer icon='ph--text-aa--regular'>
-      <MarkdownCard subject={subject} {...args} />
+      <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/Card',
+  title: 'plugins/plugin-markdown/containers/MarkdownCard',
   component: MarkdownCardStory,
   decorators: [
-    withTheme,
+    withTheme(),
     withPluginManager({
-      plugins: [OperationPlugin()],
+      plugins: [OperationPlugin(), RuntimePlugin(), ClientPlugin({})],
     }),
   ],
   parameters: {

package/src/containers/MarkdownCard/MarkdownCard.tsx

@@ -0,0 +1,62 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { Obj } from '@dxos/echo';
+import { Card, useTranslation } from '@dxos/react-ui';
+import { Editor } from '@dxos/react-ui-editor';
+import { Text } from '@dxos/schema';
+
+import { MarkdownEditor, MarkdownEditorProvider } 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.Section className='px-1'>
+          <MarkdownEditorProvider id={subject.id} viewMode='readonly' extensions={extensions}>
+            {(editorRootProps) => (
+              <Editor.Root {...editorRootProps}>
+                <MarkdownEditor.Content initialValue={snippet} slots={{ content: { className: 'm-0' } }} />
+              </Editor.Root>
+            )}
+          </MarkdownEditorProvider>
+        </Card.Section>
+      )}
+      <Card.Section>
+        <Card.Text classNames='px-1.5 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,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { MarkdownCard as default } from './MarkdownCard';

package/src/containers/MarkdownCard/snippet.ts

@@ -0,0 +1,78 @@
+//
+// 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 deduplicates concurrent requests within the same animation frame.
+          key: this,
+          read: (view) => {
+            const containerHeight = view.dom.clientHeight;
+            if (containerHeight === 0) {
+              return 0;
+            }
+            // With CSS zoom, clientHeight can be in visual pixels while line positions use
+            // layout pixels (same space as internalHeight / theme maxHeight).
+            const clipLimit = scale === 1 ? containerHeight : Math.min(internalHeight, containerHeight / scale);
+            // Find the block (line) at the very bottom of the visible area.
+            const block = view.lineBlockAtHeight(clipLimit - 1);
+            // If the block overflows the container, clip at the block's top edge.
+            return block.top + block.height > clipLimit ? block.top : clipLimit;
+          },
+          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,33 +6,46 @@ 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 { random } from '@dxos/random';
+import { useQuery, useSpaces } 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 { withLayout } from '@dxos/react-ui/testing';
 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 { Markdown, MarkdownCapabilities, MarkdownEvents } from '#types';
 
-faker.seed(1);
+import { MarkdownPlugin } from '../../MarkdownPlugin';
+import { translations } from '../../translations';
 
-const generator: ValueGenerator = faker as any;
+random.seed(1);
+
+const generator: ValueGenerator = random 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 [space] = useSpaces();
   const [doc] = useQuery(space?.db, Query.type(Markdown.Document));
   const data = useMemo(() => ({ subject: doc }), [doc]);
   const id = doc && Obj.getDXN(doc).toString();
@@ -40,45 +53,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 +106,7 @@ const meta = {
                 }),
               );
 
-              yield* Effect.promise(() => space.db.flush({ indexes: true }));
+              yield* Effect.promise(() => personalSpace.db.flush({ indexes: true }));
             }),
         }),