@dxos/plugin-thread 0.8.4-main.4a85c3132b → 0.8.4-main.51f1e5ca51

package/src/operations/delete-message.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Obj, Relation } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+import { Thread } from '@dxos/types';
+
+import { Delete, DeleteMessage } from './definitions';
+
+const handler: Operation.WithHandler<typeof DeleteMessage> = DeleteMessage.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ subject, anchor, messageId }) {
+      const thread = Relation.getSource(anchor) as Thread.Thread;
+      const db = Obj.getDatabase(subject);
+      invariant(db, 'Database not found');
+
+      const msgIndex = thread.messages.findIndex((ref) => ref.target?.id === messageId);
+      const msg = thread.messages[msgIndex]?.target;
+      if (!msg) {
+        return { messageIndex: -1 };
+      }
+
+      if (msgIndex === 0 && thread.messages.length === 1) {
+        // TODO(wittjosiah): This doesn't support restoring the thread.
+        yield* Operation.invoke(Delete, { subject, anchor });
+        return { messageIndex: -1 };
+      }
+
+      Obj.update(thread, (thread) => {
+        thread.messages.splice(msgIndex, 1);
+      });
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.message.delete',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+          threadLength: thread.messages.length,
+          messageId,
+        },
+      });
+
+      return { message: msg, messageIndex: msgIndex };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/delete.ts

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { sleep } from '@dxos/async';
+import { Operation } from '@dxos/compute';
+import { Obj, Relation } from '@dxos/echo';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+import { Thread } from '@dxos/types';
+
+import { ThreadCapabilities } from '../types';
+import { Delete } from './definitions';
+
+const handler: Operation.WithHandler<typeof Delete> = Delete.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ subject, anchor, thread: _thread }) {
+      const registry = yield* Capability.get(Capabilities.AtomRegistry);
+      const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+      const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
+      const subjectId = Obj.getDXN(subject).toString();
+      const state = registry.get(stateAtom);
+      const draft = state.drafts[subjectId];
+      if (draft) {
+        const index = draft.findIndex((a: { id: string }) => a.id === anchor.id);
+        if (index !== -1) {
+          registry.set(stateAtom, {
+            ...state,
+            drafts: {
+              ...state.drafts,
+              [subjectId]: state.drafts[subjectId]?.filter((_, i) => i !== index),
+            },
+          });
+          return {};
+        }
+      }
+
+      const db = Obj.getDatabase(thread);
+      if (!db) {
+        return {};
+      }
+
+      // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
+      db.remove(anchor);
+      yield* Effect.promise(() => sleep(100));
+      db.remove(thread);
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.delete',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+        },
+      });
+
+      return { thread, anchor };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export * as ThreadOperation from './definitions';
+
+export const ThreadOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./add-message'),
+  () => import('./create'),
+  () => import('./create-channel'),
+  () => import('./create-channel-thread'),
+  () => import('./create-proposals'),
+  () => import('./delete'),
+  () => import('./delete-message'),
+  () => import('./on-create-space'),
+  () => import('./restore'),
+  () => import('./restore-message'),
+  () => import('./select'),
+  () => import('./toggle-resolved'),
+);

package/src/operations/on-create-space.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { CreateChannel, OnCreateSpace } from './definitions';
+
+const handler: Operation.WithHandler<typeof OnCreateSpace> = OnCreateSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ space, isDefault }) {
+      if (isDefault) {
+        return;
+      }
+
+      const { object: channel } = yield* Operation.invoke(CreateChannel, {
+        name: 'General',
+        spaceId: space.id,
+      });
+      space.db.add(channel);
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/restore-message.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Obj, Ref, Relation } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+import { Thread } from '@dxos/types';
+
+import { RestoreMessage } from './definitions';
+
+const handler: Operation.WithHandler<typeof RestoreMessage> = RestoreMessage.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ anchor, message, messageIndex }) {
+      const thread = Relation.getSource(anchor) as Thread.Thread;
+      const db = Obj.getDatabase(thread);
+      invariant(db, 'Database not found');
+
+      Obj.update(thread, (thread) => {
+        thread.messages.splice(messageIndex, 0, Ref.make(message));
+      });
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.message.undo-delete',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+          messageId: message.id,
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/restore.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { sleep } from '@dxos/async';
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+
+import { Restore } from './definitions';
+
+const handler: Operation.WithHandler<typeof Restore> = Restore.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ thread, anchor }) {
+      const db = Obj.getDatabase(thread);
+      if (!db) {
+        return;
+      }
+
+      // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
+      db.add(thread);
+      yield* Effect.promise(() => sleep(100));
+      db.add(anchor);
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.undo-delete',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/select.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+
+import { ThreadCapabilities } from '../types';
+import { Select } from './definitions';
+
+const handler: Operation.WithHandler<typeof Select> = Select.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const registry = yield* Capability.get(Capabilities.AtomRegistry);
+      const stateAtom = yield* Capability.get(ThreadCapabilities.State);
+      const current = registry.get(stateAtom);
+      registry.set(stateAtom, { ...current, current: input.current });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/toggle-resolved.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+
+import { ToggleResolved } from './definitions';
+
+const handler: Operation.WithHandler<typeof ToggleResolved> = ToggleResolved.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const thread = input.thread;
+
+      Obj.update(thread, (thread) => {
+        if (thread.status === 'active' || thread.status === undefined) {
+          thread.status = 'resolved';
+        } else if (thread.status === 'resolved') {
+          thread.status = 'active';
+        }
+      });
+
+      const db = Obj.getDatabase(thread);
+      invariant(db, 'Database not found');
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'threads.toggle-resolved',
+        properties: {
+          spaceId: db.spaceId,
+          threadId: thread.id,
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/{components/testing.ts → testing/data.ts}

@@ -4,22 +4,22 @@
 
 import { Obj, Ref } from '@dxos/echo';
 import { IdentityDid } from '@dxos/keys';
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 import { type Identity } from '@dxos/react-client/halo';
 import { Message, Thread } from '@dxos/types';
 
 export const createCommentThread = (identity: Identity): Thread.Thread => {
   return Thread.make({
     name: 'Comment',
-    messages: faker.helpers.multiple(
+    messages: random.helpers.multiple(
       () =>
         Ref.make(
           Obj.make(Message.Message, {
             created: new Date().toISOString(),
             sender: {
-              identityDid: faker.datatype.boolean() ? identity.did : IdentityDid.random(),
+              identityDid: random.datatype.boolean() ? identity.did : IdentityDid.random(),
             },
-            blocks: [{ _tag: 'text', text: faker.lorem.sentences(3) }],
+            blocks: [{ _tag: 'text', text: random.lorem.sentences(3) }],
           }),
         ),
       { count: { min: 2, max: 3 } },
@@ -31,15 +31,15 @@ export const createCommentThread = (identity: Identity): Thread.Thread => {
 export const createProposalThread = (identity: Identity): Thread.Thread => {
   return Thread.make({
     name: 'Proposal',
-    messages: faker.helpers.multiple(
+    messages: random.helpers.multiple(
       () =>
         Ref.make(
           Obj.make(Message.Message, {
             created: new Date().toISOString(),
             sender: {
-              identityDid: faker.datatype.boolean() ? identity.did : IdentityDid.random(),
+              identityDid: random.datatype.boolean() ? identity.did : IdentityDid.random(),
             },
-            blocks: [{ _tag: 'proposal', text: faker.lorem.sentences(3) }],
+            blocks: [{ _tag: 'proposal', text: random.lorem.sentences(3) }],
           }),
         ),
       { count: { min: 1, max: 1 } },

package/src/testing/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './stories';
+export * from './data';

package/src/translations.ts

@@ -5,96 +5,92 @@
 import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
 
-import { meta } from './meta';
-import { Channel } from './types';
+import { meta } from '#meta';
+import { Channel } from '#types';
 
 export const translations = [
   {
     'en-US': {
       [Type.getTypename(Channel.Channel)]: {
-        'typename label': 'Channel',
-        'typename label_zero': 'Channels',
-        'typename label_one': 'Channel',
-        'typename label_other': 'Channels',
-        'object name placeholder': 'New channel',
-        'rename object label': 'Rename channel',
-        'delete object label': 'Delete channel',
-        'object deleted label': 'Channel deleted',
+        'typename.label': 'Channel',
+        'typename.label_zero': 'Channels',
+        'typename.label_one': 'Channel',
+        'typename.label_other': 'Channels',
+        'object-name.placeholder': 'New channel',
+        'add-object.label': 'Add channel',
+        'rename-object.label': 'Rename channel',
+        'delete-object.label': 'Delete channel',
+        'object-deleted.label': 'Channel deleted',
       },
       [meta.id]: {
-        'plugin name': 'Chat',
-        'channel title label': 'Title',
-        'message placeholder': 'Reply…',
-        'activity message': 'Processing…',
-        'anonymous label': 'Anonymous',
-        'delete message block label': 'Delete message block',
-        'detached thread label': 'Referenced content was removed',
-        'delete thread label': 'Delete thread',
-        'resolve thread label': 'Resolve thread',
-        'thread deleted label': 'Thread deleted',
-        'message deleted label': 'Message deleted',
-        'comments heading': 'Comments',
-        'chat heading': 'Chat',
-        'draft button': 'DRAFT',
-        'no comments title': 'Comments',
-        'no comments message':
+        'plugin.name': 'Chat',
+        'channel-title.label': 'Title',
+        'message.placeholder': 'Reply…',
+        'activity.message': 'Processing…',
+        'anonymous.label': 'Anonymous',
+        'delete-message-block.label': 'Delete message block',
+        'detached-thread.label': 'Referenced content was removed',
+        'delete-thread.label': 'Delete thread',
+        'resolve-thread.label': 'Resolve thread',
+        'thread-deleted.label': 'Thread deleted',
+        'message-deleted.label': 'Message deleted',
+        'comments.heading': 'Comments',
+        'chat.heading': 'Chat',
+        'draft.button': 'DRAFT',
+        'no-comments.title': 'Comments',
+        'no-comments.message':
           'Click on the <commentIcon></commentIcon> button in the document toolbar to create a comment thread on the selected text.',
-        'toggle show resolved': 'Show resolved',
-        'unnamed object threads label': 'Threads',
-        'mark as resolved label': 'Mark as resolved',
-        'mark as unresolved label': 'Mark as unresolved',
-        'save message label': 'Save',
-        'edit message label': 'Edit',
-        'delete message label': 'Delete message',
-        'accept proposal label': 'Accept proposal',
-        'open comments panel label': 'Show Comments',
-        'comments label': 'Comments',
-        'show all label': 'All comments',
-        'show unresolved label': 'Unresolved comments',
-        'add comment label': 'Add comment',
+        'toggle-show-resolved.label': 'Show resolved',
+        'unnamed-object-threads.label': 'Threads',
+        'mark-as-resolved.label': 'Mark as resolved',
+        'mark-as-unresolved.label': 'Mark as unresolved',
+        'save-message.label': 'Save',
+        'edit-message.label': 'Edit',
+        'delete-message.label': 'Delete message',
+        'accept-proposal.label': 'Accept proposal',
+        'open-comments-panel.label': 'Show Comments',
+        'comments.label': 'Comments',
+        'show-all.label': 'All comments',
+        'show-unresolved.label': 'Unresolved comments',
+        'add-comment.label': 'Add comment',
 
-        'channel companion label': 'Channel',
-        'call panel label': 'Active Call',
+        'channel-companion.label': 'Channel',
+        'call-panel.label': 'Active Call',
 
-        'display name label': 'Display name',
-        'display name description': 'Set your display name before joining a meeting.',
-        'display name input placeholder': 'Enter your name',
-        'set display name label': 'Continue',
+        'display-name.label': 'Display name',
+        'display-name.description': 'Set your display name before joining a meeting.',
+        'display-name-input.placeholder': 'Enter your name',
+        'set-display-name.label': 'Continue',
 
-        'call tab label': 'Call',
-        'meeting status title': 'Calls',
-        'share meeting link label': 'Share meeting',
-        'show webrtc stats title': 'WebRTC Stats',
-        'show calls history title': 'Service History',
+        'call-tab.label': 'Call',
+        'meeting-status.title': 'Calls',
+        'share-meeting-link.label': 'Share meeting',
+        'show-webrtc-stats.title': 'WebRTC Stats',
+        'show-calls-history.title': 'Service History',
 
-        'meeting summary label': 'Summary',
-        'summarize label': 'Summarize',
-        'summarizing label': 'Creating summary...',
-        'create summary message': 'A summary doesn’t exist for this meeting yet. Create one now?',
+        'meeting-summary.label': 'Summary',
+        'summarize.label': 'Summarize',
+        'summarizing.label': 'Creating summary...',
+        'create-summary.message': 'A summary doesn’t exist for this meeting yet. Create one now?',
 
-        'join call': 'Join',
-        'leave call': 'Leave',
+        'icon-pin.label': 'Pin video',
+        'icon-unpin.label': 'Unpin video',
+        'icon-wave.label': 'Waving',
+        'icon-muted.label': 'Muted',
+        'join-call.button': 'Join',
+        'leave-call.button': 'Leave',
+        'mic-on.button': 'Unmute',
+        'mic-off.button': 'Mute',
+        'camera-on.button': 'Turn camera on',
+        'camera-off.button': 'Turn camera off',
+        'camera-off.label': 'Camera off',
+        'raise-hand.button': 'Raise hand',
+        'lower-hand.button': 'Lower hand',
+        'screenshare-on.button': 'Share screen',
+        'screenshare-off.button': 'Stop streaming',
 
-        'lobby participants_zero': 'No participants',
-        'lobby participants_one': '1 participant',
-        'lobby participants_other': '{{count}} participants',
-
-        'icon pin': 'Pin video',
-        'icon unpin': 'Unpin video',
-        'icon wave': 'Waving',
-        'icon muted': 'Muted',
-        'icon speaking': 'Speaking',
-
-        'mic on': 'Unmute',
-        'mic off': 'Mute',
-        'camera on': 'Turn camera on',
-        'camera off': 'Turn camera off',
-        'camera off label': 'Camera off',
-
-        'raise hand': 'Raise hand',
-        'lower hand': 'Lower hand',
-        'screenshare on': 'Share screen',
-        'screenshare off': 'Stop streaming',
+        'channel-toolbar.title': 'Channel actions',
+        'start-video-call.menu': 'Start video call',
       },
     },
   },

package/src/types/Channel.ts

@@ -2,12 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Schema from 'effect/Schema';
 
-import { Obj, Ref, Type } from '@dxos/echo';
+import { Annotation, Obj, Ref, Type } from '@dxos/echo';
 import { FormInputAnnotation } from '@dxos/echo/internal';
 import { Thread } from '@dxos/types';
 
+// TODO(burdon): What is the difference between Thread and Channel.
 export const Channel = Schema.Struct({
   name: Schema.optional(Schema.String),
   defaultThread: Ref.Ref(Thread.Thread).pipe(FormInputAnnotation.set(false)),
@@ -15,9 +18,13 @@ export const Channel = Schema.Struct({
   threads: Ref.Ref(Thread.Thread).pipe(Schema.Array, FormInputAnnotation.set(false)),
 }).pipe(
   Type.object({
-    typename: 'dxos.org/type/Channel',
+    typename: 'org.dxos.type.channel',
     version: '0.1.0',
   }),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--hash--regular',
+    hue: 'rose',
+  }),
 );
 
 export interface Channel extends Schema.Schema.Type<typeof Channel> {}

package/src/types/Settings.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+export const Settings = Schema.mutable(Schema.Struct({}));
+export interface Settings extends Schema.Schema.Type<typeof Settings> {}

package/src/types/capabilities.ts

@@ -6,13 +6,15 @@ import { type Atom } from '@effect-atom/atom-react';
 
 import { Capability } from '@dxos/app-framework';
 
+import { meta } from '#meta';
+
 import { type CallManager, type CallState, type MediaState } from '../calls';
-import { meta } from '../meta';
-import { type Channel, type ThreadSettingsProps, type ThreadState, type ViewStore } from '../types';
+import { type Channel, type ThreadState, type ViewStore } from '../types';
+import * as Settings from './Settings';
 
 export namespace ThreadCapabilities {
-  export const Settings = Capability.make<Atom.Writable<ThreadSettingsProps>>(`${meta.id}/capability/settings`);
-  export const CallManager = Capability.make<CallManager>(`${meta.id}/capability/call-manager`);
+  export const Settings = Capability.make<Atom.Writable<Settings.Settings>>(`${meta.id}.capability.settings`);
+  export const CallManager = Capability.make<CallManager>(`${meta.id}.capability.call-manager`);
 
   // TODO(burdon): Better way to define specific extensions for meeting companions.
   // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?
@@ -24,11 +26,11 @@ export namespace ThreadCapabilities {
     onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
   };
 
-  export const CallExtension = Capability.make<CallProperties>(`${meta.id}/capability/call-extension`);
+  export const CallExtension = Capability.make<CallProperties>(`${meta.id}.capability.call-extension`);
 
   /** Thread state (drafts, toolbar state, current selection). */
-  export const State = Capability.make<Atom.Writable<ThreadState>>(`${meta.id}/capability/state`);
+  export const State = Capability.make<Atom.Writable<ThreadState>>(`${meta.id}.capability.state`);
 
   /** Per-subject view state (e.g., showResolvedThreads). */
-  export const ViewState = Capability.make<Atom.Writable<ViewStore>>(`${meta.id}/capability/view-state`);
+  export const ViewState = Capability.make<Atom.Writable<ViewStore>>(`${meta.id}.capability.view-state`);
 }