@dxos/plugin-markdown 0.8.3 → 0.8.4-main.1da679c

package/src/extensions.tsx

@@ -2,30 +2,35 @@
 // Copyright 2023 DXOS.org
 //
 
+import { type ViewUpdate } from '@codemirror/view';
 import React, { type AnchorHTMLAttributes, type ReactNode, useMemo } from 'react';
 import { createRoot } from 'react-dom/client';
 
 import {
-  createIntent,
   LayoutAction,
   type PromiseIntentDispatcher,
+  createIntent,
   useCapabilities,
   useIntentDispatcher,
 } from '@dxos/app-framework';
+import { debounceAndThrottle } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
-import { createDocAccessor, fullyQualifiedId, getSpace, type QueryResult } from '@dxos/react-client/echo';
+import { createDocAccessor, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Icon, ThemeProvider } from '@dxos/react-ui';
 import { type SelectionManager } from '@dxos/react-ui-attention';
 import {
-  type AutocompleteResult,
+  Cursor,
   type EditorStateStore,
+  EditorView,
   type EditorViewMode,
   type Extension,
   InputModeExtensions,
+  type PreviewOptions,
+  type RenderCallback,
   createDataExtensions,
-  autocomplete,
   decorateMarkdown,
+  documentId,
   folding,
   formattingKeymap,
   linkTooltip,
@@ -33,27 +38,21 @@ import {
   preview,
   selectionState,
   typewriter,
-  type RenderCallback,
-  EditorView,
-  documentId,
-  Cursor,
-  type PreviewOptions,
 } from '@dxos/react-ui-editor';
 import { defaultTx } from '@dxos/react-ui-theme';
 import { type DataType } from '@dxos/schema';
 import { isNotFalsy } from '@dxos/util';
 
 import { MarkdownCapabilities } from './capabilities';
-import { type DocumentType, type MarkdownSettingsProps } from './types';
+import { type Markdown } from './types';
 import { setFallbackName } from './util';
 
 type ExtensionsOptions = {
-  document?: DocumentType;
+  document?: Markdown.Document;
   id?: string;
   text?: DataType.Text;
   dispatch?: PromiseIntentDispatcher;
-  query?: QueryResult<DocumentType>;
-  settings: MarkdownSettingsProps;
+  settings: Markdown.Settings;
   selectionManager?: SelectionManager;
   viewMode?: EditorViewMode;
   editorStateStore?: EditorStateStore;
@@ -172,7 +171,6 @@ const createBaseExtensions = ({
   dispatch,
   settings,
   selectionManager,
-  query,
   viewMode,
   previewOptions,
 }: ExtensionsOptions): Extension[] => {
@@ -214,30 +212,6 @@ const createBaseExtensions = ({
     );
   }
 
-  //
-  // Autocomplete object links.
-  //
-  if (query) {
-    extensions.push(
-      autocomplete({
-        onSearch: (text: string) => {
-          // TODO(burdon): Specify filter (e.g., stack).
-          return query.objects
-            .map<AutocompleteResult | undefined>((object) =>
-              object.name?.length && object.id !== document?.id
-                ? {
-                    label: object.name,
-                    // TODO(burdon): Factor out URL builder.
-                    apply: `[${object.name}](/${fullyQualifiedId(object)})`,
-                  }
-                : undefined,
-            )
-            .filter(isNotFalsy);
-        },
-      }),
-    );
-  }
-
   if (settings.debug) {
     const items = settings.typewriter?.split(/[,\n]/) ?? '';
     if (items) {
@@ -249,20 +223,22 @@ const createBaseExtensions = ({
 };
 
 export const selectionChange = (selectionManager: SelectionManager) => {
-  return EditorView.updateListener.of((update) => {
-    if (update.selectionSet) {
-      const id = update.state.facet(documentId);
-      const cursorConverter = update.state.facet(Cursor.converter);
-      const selection = update.state.selection;
-      const ranges = selection.ranges
-        .map((range) => ({
-          from: cursorConverter.toCursor(range.from),
-          to: cursorConverter.toCursor(range.to),
-        }))
-        .filter(({ from, to }) => to > from);
-      selectionManager.updateMultiRange(id, ranges);
-    }
-  });
+  return EditorView.updateListener.of(
+    debounceAndThrottle((update: ViewUpdate) => {
+      if (update.selectionSet) {
+        const id = update.state.facet(documentId);
+        const cursorConverter = update.state.facet(Cursor.converter);
+        const selection = update.state.selection;
+        const ranges = selection.ranges
+          .map((range) => ({
+            from: cursorConverter.toCursor(range.from),
+            to: cursorConverter.toCursor(range.to),
+          }))
+          .filter(({ from, to }) => to > from);
+        selectionManager.updateMultiRange(id, ranges);
+      }
+    }, 100),
+  );
 };
 
 // TODO(burdon): Factor out styles.

package/src/functions/diff.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import { ArtifactId, applyDiffs } from '@dxos/assistant';
+import { createDocAccessor } from '@dxos/echo-db';
+import { DatabaseService, defineFunction } from '@dxos/functions';
+import { trim } from '@dxos/util';
+
+import { Markdown } from '../types';
+
+// TODO(wittjosiah): Reconcile with ThreadAction.AddProposal.
+export default defineFunction({
+  name: 'dxos.org/function/markdown/diff',
+  description: trim`
+    Applies a set of diffs to the markdown document.
+  `,
+  inputSchema: Schema.Struct({
+    id: ArtifactId.annotations({
+      description: 'The ID of the markdown document.',
+    }),
+    diffs: Schema.Array(Schema.String).annotations({
+      description: 'The diffs to apply to the document.',
+    }),
+  }),
+  outputSchema: Schema.Void,
+  handler: Effect.fn(function* ({ data: { id, diffs } }) {
+    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
+    const content = yield* Effect.promise(() => object.content.load());
+    const accessor = createDocAccessor(content, ['content']);
+    applyDiffs(accessor, diffs);
+  }),
+});

package/src/functions/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export { default as diff } from './diff';
+export { default as open } from './open';

package/src/functions/open.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import { ArtifactId } from '@dxos/assistant';
+import { DatabaseService, defineFunction } from '@dxos/functions';
+
+import { Markdown } from '../types';
+
+export default defineFunction({
+  name: 'dxos.org/function/markdown/open',
+  description: 'Opens and reads the contents of a new markdown document.',
+  inputSchema: Schema.Struct({
+    id: ArtifactId.annotations({
+      description: 'The ID of the markdown document.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    content: Schema.String,
+  }),
+  handler: Effect.fn(function* ({ data: { id } }) {
+    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
+    const { content } = yield* Effect.promise(() => object.content.load());
+    return {
+      content,
+    };
+  }),
+});

package/src/hooks/useSelectCurrentThread.tsx

@@ -6,11 +6,11 @@ import { EditorView } from '@codemirror/view';
 import { Schema } from 'effect';
 import { useMemo } from 'react';
 
-import { createResolver, LayoutAction, useIntentResolver } from '@dxos/app-framework';
+import { LayoutAction, createResolver, useIntentResolver } from '@dxos/app-framework';
 import { invariant } from '@dxos/invariant';
 import { Cursor, setSelection } from '@dxos/react-ui-editor';
 
-import { MARKDOWN_PLUGIN } from '../meta';
+import { meta } from '../meta';
 
 /**
  * Handle scrolling and selection of the current thread in a markdown editor.
@@ -52,5 +52,5 @@ export const useSelectCurrentThread = (editorView: EditorView | undefined, docum
     [documentId, editorView],
   );
 
-  useIntentResolver(MARKDOWN_PLUGIN, scrollIntoViewResolver);
+  useIntentResolver(meta.id, scrollIntoViewResolver);
 };

package/src/index.ts

@@ -4,6 +4,9 @@
 
 export { MarkdownCapabilities } from './capabilities';
 export { MarkdownEvents } from './events';
-export * from './MarkdownPlugin';
+
 export * from './meta';
+export * from './types';
 export * from './util';
+
+export * from './MarkdownPlugin';

package/src/meta.ts

@@ -3,18 +3,17 @@
 //
 
 import { type PluginMeta } from '@dxos/app-framework';
-
-export const MARKDOWN_PLUGIN = 'dxos.org/plugin/markdown';
+import { trim } from '@dxos/util';
 
 export const meta: PluginMeta = {
-  id: MARKDOWN_PLUGIN,
+  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`
+    A collaborative and extensible Markdown editor.
+    In addition to markdown capabilities, the plugin supports collaborative in-line comments.
+    You can use documents to extend the memory of your personal agents and add context for automated workflows.
   `,
-  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-markdown',
   icon: 'ph--text-aa--regular',
+  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-markdown',
   screenshots: ['https://dxos.network/plugin-details-markdown-dark.png'],
 };

package/src/translations.ts

@@ -2,23 +2,26 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Type } from '@dxos/echo';
+import { type Resource } from '@dxos/react-ui';
 
-import { MARKDOWN_PLUGIN } from './meta';
-import { DocumentType } from './types';
+import { meta } from './meta';
+import { Markdown } from './types';
 
-export default [
+export const translations = [
   {
     'en-US': {
-      [Type.getTypename(DocumentType)]: {
+      [Markdown.Document.typename]: {
         'typename label': 'Document',
         'typename label_zero': 'Documents',
         'typename label_one': 'Document',
         'typename label_other': 'Documents',
         'object name placeholder': 'New document',
+        'rename object label': 'Rename document',
+        'delete object label': 'Delete document',
       },
-      [MARKDOWN_PLUGIN]: {
+      [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?',
@@ -43,4 +46,4 @@ export default [
       },
     },
   },
-];
+] as const satisfies Resource[];

package/src/types/Markdown.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { Obj, Ref, Type } from '@dxos/echo';
+import { LabelAnnotation } from '@dxos/echo-schema';
+import { EditorInputMode, EditorViewMode } from '@dxos/react-ui-editor/types';
+import { DataType, ItemAnnotation } from '@dxos/schema';
+
+/**
+ * Document Item type.
+ */
+export const Document = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  fallbackName: Schema.optional(Schema.String),
+  content: Type.Ref(DataType.Text),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Document',
+    version: '0.1.0',
+  }),
+  LabelAnnotation.set(['name', 'fallbackName']),
+  ItemAnnotation.set(true),
+);
+
+export type Document = Schema.Schema.Type<typeof Document>;
+
+/**
+ * Document factory.
+ */
+export const makeDocument = ({
+  content = '',
+  ...props
+}: Partial<{ name: string; fallbackName: string; content: string }> = {}) =>
+  Obj.make(Document, { ...props, content: Ref.make(DataType.makeText(content)) });
+
+/**
+ * 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,29 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { EditorViewMode } from '@dxos/react-ui-editor/types';
+
+import { meta } from '../meta';
+
+import { Document } from './Markdown';
+
+export class Create extends Schema.TaggedClass<Create>()(`${meta.id}/action/create`, {
+  input: Schema.Struct({
+    name: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String),
+  }),
+  output: Schema.Struct({
+    object: Document,
+  }),
+}) {}
+
+export class SetViewMode extends Schema.TaggedClass<SetViewMode>()(`${meta.id}/action/set-view-mode`, {
+  input: Schema.Struct({
+    id: Schema.String,
+    viewMode: EditorViewMode,
+  }),
+  output: Schema.Void,
+}) {}

package/src/types/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './schema';
+export * as MarkdownAction from './MarkdownAction';
+export * as Markdown from './Markdown';
 export * from './types';

package/src/types/types.ts

@@ -2,44 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { type Extension } from '@dxos/react-ui-editor';
+import { type EditorViewMode } from '@dxos/react-ui-editor/types';
 
-import { Type } from '@dxos/echo';
-// TODO(wittjosiah): This pulls in UI code into the types entrypoint.
-import { type Extension, EditorInputMode, EditorViewMode } from '@dxos/react-ui-editor';
+import { type Document } from './Markdown';
 
-import { DocumentType } from './schema';
-import { MARKDOWN_PLUGIN } from '../meta';
+// 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.
 
-const MARKDOWN_ACTION = `${MARKDOWN_PLUGIN}/action`;
-
-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 +21,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.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)
@@ -26,14 +40,14 @@ export const getAbstract = (content: string) => {
   return content.substring(0, 128).split('\n')[0].replaceAll(nonTitleChars, '').trim();
 };
 
-export const setFallbackName = debounce((doc: DocumentType, content: string) => {
+export const setFallbackName = debounce((doc: Markdown.Document, content: string) => {
   const name = getFallbackName(content);
   if (doc.fallbackName !== name) {
     doc.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 +55,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.makeDocument({ name, fallbackName, content });
   },
 };