@dxos/plugin-markdown 0.8.4-main.2e9d522 → 0.8.4-main.3eb6e50203

package/src/types/Markdown.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { 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: Type.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'),
+);
+
+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,59 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/operation';
+import { SpaceSchema } from '@dxos/react-client/echo';
+import { Collection } from '@dxos/schema';
+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 = '') => {
+  const abstract = content
+    .split('\n')
+    .filter((line) => !line.startsWith('!'))
+    .filter((line) => line.trim() !== '');
+
+  return abstract.slice(0, 3).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 });
   },
 };