@dxos/plugin-markdown 0.8.4-main.2e9d522 → 0.8.4-main.548089c

package/src/hooks/useSelectCurrentThread.tsx

@@ -3,25 +3,32 @@
 //
 
 import { EditorView } from '@codemirror/view';
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { useMemo } from 'react';
 
-import { createResolver, LayoutAction, useIntentResolver } from '@dxos/app-framework';
+import { LayoutAction, createResolver } from '@dxos/app-framework';
+import { useIntentResolver } from '@dxos/app-framework/react';
 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.
  */
-export const useSelectCurrentThread = (editorView: EditorView | undefined, documentId: string) => {
+export const useSelectCurrentThread = (editorView: EditorView | null, documentId: string) => {
   const scrollIntoViewResolver = useMemo(
     () =>
       createResolver({
         intent: LayoutAction.UpdateLayout,
         position: 'hoist',
-        filter: (data): data is { part: 'current'; subject: string; options: { cursor: string } } => {
+        filter: (
+          data,
+        ): data is {
+          part: 'current';
+          subject: string;
+          options: { cursor: string };
+        } => {
           if (!Schema.is(LayoutAction.ScrollIntoView.fields.input)(data)) {
             return false;
           }
@@ -35,7 +42,10 @@ export const useSelectCurrentThread = (editorView: EditorView | undefined, docum
             const selection = editorView.state.selection.main.from !== range.from ? { anchor: range.from } : undefined;
             const effects = [
               // NOTE: This does not use the DOM scrollIntoView function.
-              EditorView.scrollIntoView(range.from, { y: 'start', yMargin: 96 }),
+              EditorView.scrollIntoView(range.from, {
+                y: 'start',
+                yMargin: 96,
+              }),
             ];
             if (selection) {
               // Update the editor selection to get bi-directional highlighting.
@@ -52,5 +62,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`
+    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 { PropertiesType } from '@dxos/client-protocol';
+import { Obj, Ref } from '@dxos/echo';
+import { DatabaseService } from '@dxos/functions';
+import { Collection } from '@dxos/schema';
+
+// TODO(wittjosiah): Factor out.
+export const WithProperties = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | DatabaseService> =>
+  Effect.zipRight(
+    Effect.gen(function* () {
+      // TODO(wittjosiah): Remove cast.
+      yield* DatabaseService.add(
+        Obj.make(PropertiesType as any, {
+          [Collection.Collection.typename]: Ref.make(Collection.make()),
+        }) as any,
+      );
+    }),
+    effect,
+  );
+
+export const testToolkit = Toolkit.empty as Toolkit.Toolkit<any>;

package/src/toolkit.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { MarkdownBlueprint, MARKDOWN_BLUEPRINT_KEY } from './capabilities/blueprint-definition';
+export { MarkdownFunction } from './functions';

package/src/translations.ts

@@ -5,12 +5,12 @@
 import { type Resource } from '@dxos/react-ui';
 
 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',
@@ -21,6 +21,7 @@ export const translations = [
       },
       [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,6 +43,9 @@ 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',
       },
     },
   },

package/src/types/Markdown.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Obj, Ref, Type } from '@dxos/echo';
+import { DescriptionAnnotation, FormAnnotation, LabelAnnotation } from '@dxos/echo/internal';
+import { EditorInputMode, EditorViewMode } from '@dxos/react-ui-editor/types';
+import { ItemAnnotation, Text } from '@dxos/schema';
+
+/**
+ * Document Item type.
+ */
+export const Document = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  fallbackName: Schema.String.pipe(FormAnnotation.set(false), Schema.optional),
+  content: Type.Ref(Text.Text).pipe(FormAnnotation.set(false)),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Document',
+    version: '0.1.0',
+  }),
+  LabelAnnotation.set(['name', 'fallbackName']),
+  DescriptionAnnotation.set('description'),
+  ItemAnnotation.set(true),
+);
+
+export type Document = Schema.Schema.Type<typeof Document>;
+
+/**
+ * Document factory.
+ */
+export const make = ({
+  content = '',
+  ...props
+}: Partial<{ name: string; fallbackName: string; content: string }> = {}) =>
+  Obj.make(Document, { ...props, content: Ref.make(Text.make(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 * as Schema from 'effect/Schema';
+
+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,7 @@
 // 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 } from '@dxos/echo';
 import { type Extension } from '@dxos/react-ui-editor';
-import { EditorInputMode, EditorViewMode } from '@dxos/react-ui-editor/types';
-
-import { DocumentType } from './schema';
-import { MARKDOWN_PLUGIN } from '../meta';
-
-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,
-    }),
-  }) {}
+import { type EditorViewMode } from '@dxos/react-ui-editor/types';
 
-  export class SetViewMode extends Schema.TaggedClass<SetViewMode>()(`${MARKDOWN_ACTION}/set-view-mode`, {
-    input: Schema.Struct({
-      id: Schema.String,
-      viewMode: EditorViewMode,
-    }),
-    output: Schema.Void,
-  }) {}
-}
+import { type Document } from './Markdown';
 
-export type MarkdownProperties = Record<string, any>;
+// 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.
 
-// 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)
@@ -18,22 +32,27 @@ export const isMarkdownProperties = (data: unknown): data is MarkdownProperties
 
 const nonTitleChars = /[^\w ]/g;
 
-export const getFallbackName = (content: string) => {
+export const getFallbackName = (content = '') => {
   return content.substring(0, 31).split('\n')[0].replaceAll(nonTitleChars, '').trim();
 };
 
-export const getAbstract = (content: string) => {
-  return content.substring(0, 128).split('\n')[0].replaceAll(nonTitleChars, '').trim();
+export const getContentSnippet = (content = '') => {
+  const abstract = content
+    .split('\n')
+    .filter((line) => !line.startsWith('#'))
+    .filter((line) => line.trim() !== '');
+
+  return abstract.length > 0 ? abstract[0].replaceAll(nonTitleChars, '').trim() + '...' : '';
 };
 
-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;
   }
 }, 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 +60,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 });
   },
 };