@dxos/plugin-markdown 0.8.4-main.f5c0578 → 0.8.4-main.fcfe5033a5

package/src/operations/definitions.ts

@@ -0,0 +1,120 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Database, Ref } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { EditorViewMode } from '@dxos/ui-editor/types';
+import { trim } from '@dxos/util';
+
+import { meta } from '#meta';
+
+import { Markdown } from '../types';
+
+const MARKDOWN_OPERATION = `${meta.id}.operation`;
+
+const Edit = Schema.Struct({
+  oldString: Schema.String.annotations({
+    description: 'The text to find in the document.',
+  }),
+  newString: Schema.String.annotations({
+    description: 'The text to replace it with.',
+  }),
+  replaceAll: Schema.optional(Schema.Boolean).annotations({
+    description: 'If true, replaces all occurrences. Defaults to false (first occurrence only).',
+  }),
+});
+
+export const Create = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.create',
+    name: 'Create',
+    description: 'Creates a new markdown document and adds it to the space.',
+  },
+  input: Schema.Struct({
+    name: Schema.String,
+    content: Schema.String,
+  }),
+  output: Schema.Struct({
+    id: Schema.String.annotations({
+      description: 'The DXN of the created document.',
+    }),
+  }),
+  services: [Database.Service],
+});
+
+export const CreateMarkdown = Operation.make({
+  meta: { key: `${MARKDOWN_OPERATION}.create`, name: 'Create Markdown Document' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    name: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String),
+  }),
+  output: Schema.Struct({
+    object: Markdown.Document,
+  }),
+});
+
+export const Open = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.open',
+    name: 'Open',
+    description: 'Opens and reads the contents of a new markdown document.',
+  },
+  input: Schema.Struct({
+    doc: Ref.Ref(Markdown.Document).annotations({
+      description: 'The ID of the markdown document.',
+    }),
+  }),
+  output: Schema.Struct({
+    content: Schema.String,
+  }),
+  services: [Database.Service],
+});
+
+export const ScrollToAnchor = Operation.make({
+  meta: { key: `${MARKDOWN_OPERATION}.scroll-to-anchor`, name: 'Scroll To Anchor' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    subject: Schema.String.annotations({ description: 'Attendable ID of the markdown editor.' }),
+    cursor: Schema.String.annotations({ description: 'Cursor position to scroll to.' }),
+    ref: Schema.optional(Schema.String.annotations({ description: 'Reference ID (e.g. thread ID).' })),
+  }),
+  output: Schema.Void,
+});
+
+// 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],
+  input: Schema.Struct({
+    id: Schema.String,
+    viewMode: EditorViewMode,
+  }),
+  output: Schema.Void,
+});
+
+export const Update = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.update',
+    name: 'Update',
+    description: trim`
+      Applies a set of edits to the markdown document.
+    `,
+  },
+  input: Schema.Struct({
+    doc: Ref.Ref(Markdown.Document).annotations({
+      description: 'The ID of the markdown document.',
+    }),
+    edits: Schema.Array(Edit).annotations({
+      description: 'The edits to apply to the document. Each edit finds oldString and replaces it with newString.',
+    }),
+  }),
+  output: Schema.Struct({
+    newContent: Schema.String,
+  }),
+  services: [Database.Service],
+});

package/src/operations/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * as MarkdownOperation from './definitions';
+
+export const MarkdownOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./create'),
+  () => import('./create-markdown'),
+  () => import('./open'),
+  () => import('./scroll-to-anchor'),
+  () => import('./set-view-mode'),
+  () => import('./update'),
+);

package/src/operations/open.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { Open } from './definitions';
+
+const handler: Operation.WithHandler<typeof Open> = Open.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ doc }) {
+      const { content } = yield* doc.pipe(
+        Database.load,
+        Effect.map((_) => _.content),
+        Effect.flatMap(Database.load),
+      );
+      return { content };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/scroll-to-anchor.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EditorView } from '@codemirror/view';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/operation';
+import { Cursor, setSelection } from '@dxos/ui-editor';
+
+import { MarkdownCapabilities } from '../types';
+import { ScrollToAnchor } from './definitions';
+
+const handler: Operation.WithHandler<typeof ScrollToAnchor> = ScrollToAnchor.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ subject, cursor }) {
+      const editorViews = yield* Capability.get(MarkdownCapabilities.EditorViews);
+      const entry = editorViews.get(subject);
+      if (!entry) {
+        return;
+      }
+      const range = Cursor.getRangeFromCursor(entry.view.state, cursor);
+      if (range) {
+        const selection = entry.view.state.selection.main.from !== range.from ? { anchor: range.from } : undefined;
+        const effects: any[] = [EditorView.scrollIntoView(range.from, { y: 'start', yMargin: 96 })];
+        if (selection) {
+          effects.push(setSelection.of({ current: entry.documentId }));
+        }
+        entry.view.dispatch({
+          effects,
+          selection: selection ? { anchor: range.from } : undefined,
+        });
+      }
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/set-view-mode.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { Operation } from '@dxos/operation';
+
+import { MarkdownCapabilities } from '../types';
+import { SetViewMode } from './definitions';
+
+const handler: Operation.WithHandler<typeof SetViewMode> = SetViewMode.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ id, viewMode }) {
+      yield* Capabilities.updateAtomValue(MarkdownCapabilities.State, (current) => ({
+        ...current,
+        viewMode: { ...current.viewMode, [id]: viewMode },
+      }));
+    }),
+  ),
+);
+
+export default handler;