@dxos/plugin-markdown 0.8.4-main.c1de068 → 0.8.4-main.c85a9c8dae

package/src/meta.ts

@@ -2,19 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
-export const MARKDOWN_PLUGIN = 'dxos.org/plugin/markdown';
-
-export const meta: PluginMeta = {
-  id: MARKDOWN_PLUGIN,
+export const meta: Plugin.Meta = {
+  id: 'dxos.org/plugin/markdown',
   name: 'Markdown',
-  description: `
-    A Markdown editor that is collaborative and fully extensible. It provides rich text editing as well as read only and markdown view.
-    In addition to markdown capabilities, it also support threaded in-line comments which can be accessed from the right hand sidebar at any times inside the document.
-    Your AI agent will have access to all markdown docs in your Space which means you can use them to extend the memory of your personal agent and add long term context for automated workflows.
+  description: trim`
+    Full-featured collaborative markdown editor with real-time editing, inline comments, and rich formatting.
+    Supports AI-powered editing assistance and seamlessly integrates with other workspace objects.
   `,
-  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-markdown',
   icon: 'ph--text-aa--regular',
+  iconHue: 'indigo',
+  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-markdown',
   screenshots: ['https://dxos.network/plugin-details-markdown-dark.png'],
 };

package/src/testing.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Toolkit from '@effect/ai/Toolkit';
+import * as Effect from 'effect/Effect';
+
+import { SpaceProperties } from '@dxos/client-protocol';
+import { Obj, Ref } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+
+// TODO(wittjosiah): Factor out.
+export const WithProperties = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | Database.Service> =>
+  Effect.zipRight(
+    Effect.gen(function* () {
+      // TODO(wittjosiah): Remove cast.
+      yield* Database.add(
+        Obj.make(SpaceProperties, {
+          [Collection.Collection.typename]: Ref.make(Collection.make()),
+        }) as any,
+      );
+    }),
+    effect,
+  );
+
+export const testToolkit = Toolkit.empty as Toolkit.Toolkit<any>;

package/src/translations.ts

@@ -3,14 +3,15 @@
 //
 
 import { type Resource } from '@dxos/react-ui';
+import { translations as editorTranslations } from '@dxos/react-ui-editor';
 
 import { meta } from './meta';
-import { DocumentType } from './types';
+import { Markdown } from './types';
 
 export const translations = [
   {
     'en-US': {
-      [DocumentType.typename]: {
+      [Markdown.Document.typename]: {
         'typename label': 'Document',
         'typename label_zero': 'Documents',
         'typename label_one': 'Document',
@@ -18,9 +19,11 @@ export const translations = [
         'object name placeholder': 'New document',
         'rename object label': 'Rename document',
         'delete object label': 'Delete document',
+        'object deleted label': 'Document deleted',
       },
       [meta.id]: {
         'plugin name': 'Editor',
+        'settings title': 'Editor settings',
         'choose markdown from space dialog title': 'Choose one or more documents to add',
         // TODO(burdon): Style-guide for user-facing text (e.g., hints, questions, capitalization, etc.)
         'empty choose markdown from space message': 'None available; try creating a new one instead?',
@@ -42,7 +45,11 @@ export const translations = [
         'upload image label': 'Upload image',
         'fallback title': 'Untitled',
         'navigate to document label': 'Open document',
+        'words label_zero': 'words',
+        'words label_one': 'word',
+        'words label_other': 'words',
       },
     },
   },
+  ...editorTranslations,
 ] as const satisfies Resource[];

package/src/types/Markdown.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { DescriptionAnnotation, FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';
+import { Text } from '@dxos/schema';
+import { EditorInputMode, EditorViewMode } from '@dxos/ui-editor/types';
+
+/**
+ * Document Item type.
+ */
+export const Document = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  fallbackName: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
+  content: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Document',
+    version: '0.1.0',
+  }),
+  LabelAnnotation.set(['name', 'fallbackName']),
+  DescriptionAnnotation.set('description'),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--text-aa--regular',
+    hue: 'green',
+  }),
+);
+
+export type Document = Schema.Schema.Type<typeof Document>;
+
+/**
+ * Document factory.
+ */
+export const make = ({
+  content = '',
+  ...props
+}: Partial<{ name: string; fallbackName: string; content: string }> = {}) => {
+  const doc = Obj.make(Document, { ...props, content: Ref.make(Text.make(content)) });
+  // TODO(dmaretskyi): We need a better way to set parents when creating hierarchies.
+  Obj.setParent(doc.content.target!, doc);
+  return doc;
+};
+
+/**
+ * Plugin settings.
+ */
+export const Settings = Schema.mutable(
+  Schema.Struct({
+    defaultViewMode: EditorViewMode,
+    editorInputMode: Schema.optional(EditorInputMode),
+    experimental: Schema.optional(Schema.Boolean),
+    debug: Schema.optional(Schema.Boolean),
+    toolbar: Schema.optional(Schema.Boolean),
+    typewriter: Schema.optional(Schema.String),
+    // TODO(burdon): Per document settings.
+    numberedHeadings: Schema.optional(Schema.Boolean),
+    folding: Schema.optional(Schema.Boolean),
+  }),
+);
+
+export interface Settings extends Schema.Schema.Type<typeof Settings> {}

package/src/types/MarkdownAction.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Collection } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { SpaceSchema } from '@dxos/react-client/echo';
+import { EditorViewMode } from '@dxos/ui-editor/types';
+
+import { meta } from '../meta';
+
+import { Document } from './Markdown';
+
+const MARKDOWN_OPERATION = `${meta.id}/operation`;
+
+export namespace MarkdownOperation {
+  export const OnCreateSpace = Operation.make({
+    meta: { key: `${MARKDOWN_OPERATION}/on-create-space`, name: 'On Create Space' },
+    services: [Capability.Service],
+    schema: {
+      input: Schema.Struct({
+        space: SpaceSchema,
+        rootCollection: Collection.Collection,
+        isDefault: Schema.optional(Schema.Boolean),
+      }),
+      output: Schema.Void,
+    },
+  });
+
+  export const Create = Operation.make({
+    meta: { key: `${MARKDOWN_OPERATION}/create`, name: 'Create Markdown Document' },
+    services: [Capability.Service],
+    schema: {
+      input: Schema.Struct({
+        name: Schema.optional(Schema.String),
+        content: Schema.optional(Schema.String),
+      }),
+      output: Schema.Struct({
+        object: Document,
+      }),
+    },
+  });
+
+  // TODO(wittjosiah): This appears to be unused.
+  export const SetViewMode = Operation.make({
+    meta: { key: `${MARKDOWN_OPERATION}/set-view-mode`, name: 'Set View Mode' },
+    services: [Capability.Service],
+    schema: {
+      input: Schema.Struct({
+        id: Schema.String,
+        viewMode: EditorViewMode,
+      }),
+      output: Schema.Void,
+    },
+  });
+}

package/src/types/capabilities.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Atom } from '@effect-atom/atom-react';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { type EditorStateStore, type EditorViewMode } from '@dxos/ui-editor';
+
+import { meta } from '../meta';
+
+import type * as Markdown from './Markdown';
+import { type MarkdownExtensionProvider } from './types';
+
+/** Schema for persisted markdown state. */
+export const MarkdownStateSchema = Schema.mutable(
+  Schema.Struct({
+    viewMode: Schema.Record({ key: Schema.String, value: Schema.String }),
+  }),
+);
+
+export type MarkdownState = {
+  viewMode: Record<string, EditorViewMode>;
+};
+
+export namespace MarkdownCapabilities {
+  export const Settings = Capability.make<Atom.Writable<Markdown.Settings>>(`${meta.id}/capability/settings`);
+
+  /** Persisted state atom for view mode per document. */
+  export const State = Capability.make<Atom.Writable<MarkdownState>>(`${meta.id}/capability/state`);
+
+  /** Editor state store for cursor positions, scroll state, etc. */
+  export const EditorState = Capability.make<EditorStateStore>(`${meta.id}/capability/editor-state`);
+
+  // TODO(burdon): Move to ./types (external API)?
+  export const Extensions = Capability.make<MarkdownExtensionProvider[]>(`${meta.id}/capability/extensions`);
+}

package/src/types/events.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ActivationEvent } from '@dxos/app-framework';
+import { AppActivationEvents } from '@dxos/app-toolkit';
+
+import { meta } from '../meta';
+
+export namespace MarkdownEvents {
+  export const SetupExtensions: ActivationEvent.ActivationEvent = AppActivationEvents.createStateEvent(
+    `${meta.id}/event/setup-extensions`,
+  );
+}

package/src/types/index.ts

@@ -2,5 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './schema';
+export * as MarkdownAction from './MarkdownAction';
+export { MarkdownOperation } from './MarkdownAction';
+export * as Markdown from './Markdown';
+
+export * from './capabilities';
+export * from './events';
 export * from './types';

package/src/types/types.ts

@@ -2,44 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { type Extension } from '@codemirror/state';
 
-import { Type } from '@dxos/echo';
-import { type Extension } from '@dxos/react-ui-editor';
-import { EditorInputMode, EditorViewMode } from '@dxos/react-ui-editor/types';
+import { type EditorViewMode } from '@dxos/ui-editor/types';
 
-import { DocumentType } from './schema';
-import { MARKDOWN_PLUGIN } from '../meta';
+import { type Document } from './Markdown';
 
-const MARKDOWN_ACTION = `${MARKDOWN_PLUGIN}/action`;
+// TODO(burdon): Remove these from ./types since not part of plugin-markdown API?
+// TODO(wittjosiah): MarkdownExtensionProvider is a part of the MarkdownCapabilities api which should be in ./types.
 
-export namespace MarkdownAction {
-  export class Create extends Schema.TaggedClass<Create>()(MARKDOWN_ACTION, {
-    input: Schema.Struct({
-      spaceId: Type.SpaceId,
-      name: Schema.optional(Schema.String),
-      content: Schema.optional(Schema.String),
-    }),
-    output: Schema.Struct({
-      object: DocumentType,
-    }),
-  }) {}
-
-  export class SetViewMode extends Schema.TaggedClass<SetViewMode>()(`${MARKDOWN_ACTION}/set-view-mode`, {
-    input: Schema.Struct({
-      id: Schema.String,
-      viewMode: EditorViewMode,
-    }),
-    output: Schema.Void,
-  }) {}
-}
-
-export type MarkdownProperties = Record<string, any>;
-
-// TODO(burdon): Async.
-export type MarkdownExtensionProvider = (props: { document?: DocumentType }) => Extension | undefined;
-
-export type OnChange = (text: string) => void;
+// TODO(burdon): Async?
+export type MarkdownExtensionProvider = (props: { document?: Document }) => Extension | undefined;
 
 export type MarkdownPluginState = {
   // Codemirror extensions provided by other plugins.
@@ -49,19 +22,3 @@ export type MarkdownPluginState = {
   // View mode per document.
   viewMode: Record<string, EditorViewMode>;
 };
-
-export const MarkdownSettingsSchema = Schema.mutable(
-  Schema.Struct({
-    defaultViewMode: EditorViewMode,
-    editorInputMode: Schema.optional(EditorInputMode),
-    experimental: Schema.optional(Schema.Boolean),
-    debug: Schema.optional(Schema.Boolean),
-    toolbar: Schema.optional(Schema.Boolean),
-    typewriter: Schema.optional(Schema.String),
-    // TODO(burdon): Per document settings.
-    numberedHeadings: Schema.optional(Schema.Boolean),
-    folding: Schema.optional(Schema.Boolean),
-  }),
-);
-
-export type MarkdownSettingsProps = Schema.Schema.Type<typeof MarkdownSettingsSchema>;

package/src/util.test.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from 'vitest';
+
+import { trim } from '@dxos/util';
+
+import { getFallbackName } from './util';
+
+describe('markdown utils', () => {
+  it('getFallbackName', () => {
+    const tests = [
+      {
+        content: '',
+        expected: '',
+      },
+      {
+        content: trim`
+          ![img](https://dxos.network/dxos-logotype-blue.png)
+
+          # Welcome to Composer by DXOS
+
+          ## What is Composer?
+        `,
+        expected: 'Welcome to Composer by DXOS',
+      },
+      {
+        content: trim`
+          ![img](https://dxos.network/dxos-logotype-blue.png)
+
+          ---
+
+          This document is about the decetralized platform DXOS.
+        `,
+        expected: 'This document is about the…',
+      },
+    ];
+
+    tests.forEach(({ content, expected }) => {
+      expect(getFallbackName(content)).toBe(expected);
+    });
+  });
+});

package/src/util.tsx

@@ -3,11 +3,25 @@
 //
 
 import { debounce } from '@dxos/async';
-import { Obj, Ref } from '@dxos/echo';
+import { Obj } from '@dxos/echo';
 import { type TypedObjectSerializer } from '@dxos/plugin-space/types';
-import { DataType } from '@dxos/schema';
 
-import { DocumentType, type MarkdownProperties } from './types';
+import { Markdown } from './types';
+
+/**
+ * Checks if an object conforms to the interface needed to render an editor.
+ * @deprecated Use Schema.instanceOf(Markdown.Document, data)
+ */
+// TODO(burdon): Normalize types (from FilesPlugin).
+export const isEditorModel = (data: any): data is { id: string; text: string } =>
+  data &&
+  typeof data === 'object' &&
+  'id' in data &&
+  typeof data.id === 'string' &&
+  'text' in data &&
+  typeof data.text === 'string';
+
+export type MarkdownProperties = Record<string, any>;
 
 export const isMarkdownProperties = (data: unknown): data is MarkdownProperties =>
   (Obj.isObject(data) as boolean)
@@ -18,22 +32,97 @@ export const isMarkdownProperties = (data: unknown): data is MarkdownProperties
 
 const nonTitleChars = /[^\w ]/g;
 
-export const getFallbackName = (content: string) => {
-  return content.substring(0, 31).split('\n')[0].replaceAll(nonTitleChars, '').trim();
+// Lines matching these patterns are skipped.
+const skipPatterns = [
+  /^!\[/, // Image.
+  /^---\s*$/, // Horizontal rule.
+  /^```/, // Code block fence.
+  /^\s*$/, // Empty or whitespace-only.
+];
+
+// Patterns to extract title text (first capture group is used).
+const titlePatterns = [
+  /^#{1,6}\s+(.+)/, // Heading.
+];
+
+/**
+ * Extracts a fallback name by scanning lines for the first heading or text fragment.
+ */
+export const getFallbackName = (content = ''): string => {
+  const len = content.length;
+
+  let i = 0;
+  while (i < len) {
+    // Find end of line.
+    let lineEnd = i;
+    while (lineEnd < len && content[lineEnd] !== '\n') {
+      lineEnd++;
+    }
+
+    const line = content.slice(i, lineEnd).trim();
+    i = lineEnd + 1;
+
+    // Skip lines matching skip patterns.
+    if (skipPatterns.some((pattern) => pattern.test(line))) {
+      continue;
+    }
+
+    // Check for title patterns.
+    for (const pattern of titlePatterns) {
+      const match = pattern.exec(line);
+      if (match) {
+        const text = match[1].replaceAll(nonTitleChars, '').trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+    }
+
+    // Use line as plain text fallback.
+    const maxLen = 32;
+    const text = line.replaceAll(nonTitleChars, '').trim();
+    if (text.length > 0) {
+      if (text.length > maxLen) {
+        const words = text.split(/\s+/);
+        let result = '';
+        for (const word of words) {
+          const next = result.length === 0 ? word : result + ' ' + word;
+          if (next.length > maxLen) {
+            break;
+          }
+          result = next;
+        }
+
+        return result + '…';
+      }
+
+      return text;
+    }
+  }
+
+  return '';
 };
 
-export const getAbstract = (content: string) => {
-  return content.substring(0, 128).split('\n')[0].replaceAll(nonTitleChars, '').trim();
+// TODO(burdon): Option to strip Markdown.
+export const getContentSnippet = (content = '', maxLines = 3) => {
+  const abstract = content
+    .split('\n')
+    .filter((line) => !line.startsWith('!'))
+    .filter((line) => line.trim() !== '');
+
+  return abstract.slice(0, maxLines).join('\n') ?? '';
 };
 
-export const setFallbackName = debounce((doc: DocumentType, content: string) => {
+export const setFallbackName = debounce((doc: Markdown.Document, content = '') => {
   const name = getFallbackName(content);
   if (doc.fallbackName !== name) {
-    doc.fallbackName = name;
+    Obj.change(doc, (d) => {
+      d.fallbackName = name;
+    });
   }
 }, 200);
 
-export const serializer: TypedObjectSerializer<DocumentType> = {
+export const serializer: TypedObjectSerializer<Markdown.Document> = {
   serialize: async ({ object }): Promise<string> => {
     const { content } = await object.content.load();
     return JSON.stringify({ name: object.name, fallbackName: object.fallbackName, content });
@@ -41,6 +130,6 @@ export const serializer: TypedObjectSerializer<DocumentType> = {
 
   deserialize: async ({ content: serialized }) => {
     const { name, fallbackName, content } = JSON.parse(serialized);
-    return Obj.make(DocumentType, { name, fallbackName, content: Ref.make(Obj.make(DataType.Text, { content })) });
+    return Markdown.make({ name, fallbackName, content });
   },
 };