@dxos/plugin-thread 0.7.5-main.9d2a38b → 0.7.5-main.e9bb01b

package/src/capabilities/intent-resolver.ts

@@ -8,7 +8,6 @@ import {
   createIntent,
   createResolver,
   LayoutAction,
-  NavigationAction,
   type PluginsContext,
 } from '@dxos/app-framework';
 import { Ref } from '@dxos/echo-schema';
@@ -23,201 +22,218 @@ import { ThreadAction } from '../types';
 
 export default (context: PluginsContext) =>
   contributes(Capabilities.IntentResolver, [
-    createResolver(ThreadAction.Create, ({ name, cursor, subject }) => {
-      if (cursor && subject) {
-        // Seed the threads array if it does not exist.
-        if (subject?.threads === undefined) {
-          try {
-            // Static schema will throw an error if subject does not support threads array property.
-            subject.threads = [];
-          } catch (err) {
-            log.error('Subject does not support threads array', { typename: subject?.typename });
-            return;
+    createResolver({
+      intent: ThreadAction.Create,
+      resolve: ({ name, cursor, subject }) => {
+        if (cursor && subject) {
+          // Seed the threads array if it does not exist.
+          if (subject?.threads === undefined) {
+            try {
+              // Static schema will throw an error if subject does not support threads array property.
+              subject.threads = [];
+            } catch (err) {
+              log.error('Subject does not support threads array', { typename: subject?.typename });
+              return;
+            }
           }
-        }
 
-        const { state } = context.requestCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const thread = create(ThreadType, { name, anchor: cursor, messages: [], status: 'staged' });
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          draft.push(thread);
+          const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+          const subjectId = fullyQualifiedId(subject);
+          const thread = create(ThreadType, { name, anchor: cursor, messages: [], status: 'staged' });
+          const draft = state.drafts[subjectId];
+          if (draft) {
+            draft.push(thread);
+          } else {
+            state.drafts[subjectId] = [thread];
+          }
+
+          return {
+            data: { object: thread },
+            intents: [
+              createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
+              createIntent(LayoutAction.UpdateComplementary, { part: 'complementary', subject: 'comments' }),
+            ],
+          };
         } else {
-          state.drafts[subjectId] = [thread];
+          // NOTE: This is the standalone thread creation case.
+          return {
+            data: { object: create(ChannelType, { threads: [makeRef(create(ThreadType, { messages: [] }))] }) },
+          };
         }
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.Select,
+      resolve: ({ current, skipOpen }) => {
+        const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+        state.current = current;
 
         return {
-          data: { object: thread },
-          intents: [
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
-            createIntent(NavigationAction.Open, { activeParts: { complementary: 'comments' } }),
-            createIntent(LayoutAction.SetLayout, { element: 'complementary', state: true }),
-          ],
-        };
-      } else {
-        // NOTE: This is the standalone thread creation case.
-        return {
-          data: { object: create(ChannelType, { threads: [makeRef(create(ThreadType, { messages: [] }))] }) },
+          intents: !skipOpen
+            ? [createIntent(LayoutAction.UpdateComplementary, { part: 'complementary', subject: 'comments' })]
+            : undefined,
         };
-      }
-    }),
-    createResolver(ThreadAction.Select, ({ current, skipOpen }) => {
-      const { state } = context.requestCapability(ThreadCapabilities.MutableState);
-      state.current = current;
-
-      return {
-        intents: !skipOpen
-          ? [createIntent(NavigationAction.Open, { activeParts: { complementary: 'comments' } })]
-          : undefined,
-      };
-    }),
-    createResolver(ThreadAction.ToggleResolved, ({ thread }) => {
-      if (thread.status === 'active' || thread.status === undefined) {
-        thread.status = 'resolved';
-      } else if (thread.status === 'resolved') {
-        thread.status = 'active';
-      }
-
-      const space = getSpace(thread);
-      const spaceId = space?.id;
-
-      return {
-        intents: [
-          createIntent(ObservabilityAction.SendEvent, {
-            name: 'threads.toggle-resolved',
-            properties: { threadId: thread.id, spaceId },
-          }),
-        ],
-      };
+      },
     }),
-    createResolver(ThreadAction.Delete, ({ subject, thread }, undo) => {
-      const { state } = context.requestCapability(ThreadCapabilities.MutableState);
-      const subjectId = fullyQualifiedId(subject);
-      const draft = state.drafts[subjectId];
-      if (draft) {
-        // Check if we're deleting a draft; if so, remove it.
-        const index = draft.findIndex((t) => t.id === thread.id);
-        if (index !== -1) {
-          draft.splice(index, 1);
-          return;
-        }
-      }
-
-      const space = getSpace(thread);
-      if (!space || !subject.threads) {
-        return;
-      }
-
-      if (!undo) {
-        const index = subject.threads.findIndex((t: any) => t?.id === thread.id);
-        const cursor = subject.threads[index]?.anchor;
-        if (index !== -1) {
-          subject.threads?.splice(index, 1);
+    createResolver({
+      intent: ThreadAction.ToggleResolved,
+      resolve: ({ thread }) => {
+        if (thread.status === 'active' || thread.status === undefined) {
+          thread.status = 'resolved';
+        } else if (thread.status === 'resolved') {
+          thread.status = 'active';
         }
 
-        space.db.remove(thread);
+        const space = getSpace(thread);
+        const spaceId = space?.id;
 
         return {
-          undoable: {
-            message: ['thread deleted label', { ns: THREAD_PLUGIN }],
-            data: { cursor },
-          },
           intents: [
             createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.delete',
-              properties: { threadId: thread.id, spaceId: space.id },
+              name: 'threads.toggle-resolved',
+              properties: { threadId: thread.id, spaceId },
             }),
           ],
         };
-      } else {
-        // TODO(wittjosiah): SDK should do this automatically.
-        const savedThread = space.db.add(thread);
-        subject.threads.push(savedThread);
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.Delete,
+      resolve: ({ subject, thread }, undo) => {
+        const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+        const subjectId = fullyQualifiedId(subject);
+        const draft = state.drafts[subjectId];
+        if (draft) {
+          // Check if we're deleting a draft; if so, remove it.
+          const index = draft.findIndex((t) => t.id === thread.id);
+          if (index !== -1) {
+            draft.splice(index, 1);
+            return;
+          }
+        }
 
-        return {
-          intents: [
+        const space = getSpace(thread);
+        if (!space || !subject.threads) {
+          return;
+        }
+
+        if (!undo) {
+          const index = subject.threads.findIndex((t: any) => t?.id === thread.id);
+          const cursor = subject.threads[index]?.anchor;
+          if (index !== -1) {
+            subject.threads?.splice(index, 1);
+          }
+
+          space.db.remove(thread);
+
+          return {
+            undoable: {
+              message: ['thread deleted label', { ns: THREAD_PLUGIN }],
+              data: { cursor },
+            },
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.delete',
+                properties: { threadId: thread.id, spaceId: space.id },
+              }),
+            ],
+          };
+        } else {
+          // TODO(wittjosiah): SDK should do this automatically.
+          const savedThread = space.db.add(thread);
+          subject.threads.push(savedThread);
+
+          return {
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.undo-delete',
+                properties: { threadId: thread.id, spaceId: space.id },
+              }),
+            ],
+          };
+        }
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.OnMessageAdd,
+      resolve: ({ thread, subject }) => {
+        const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+        const subjectId = fullyQualifiedId(subject);
+        const space = getSpace(subject);
+        const intents = [];
+        const analyticsProperties = { threadId: thread.id, spaceId: space?.id };
+
+        if (state.drafts[subjectId]?.find((t) => t === thread)) {
+          // Move draft to document.
+          thread.status = 'active';
+          subject.threads ? subject.threads.push(makeRef(thread)) : (subject.threads = [makeRef(thread)]);
+          state.drafts[subjectId] = state.drafts[subjectId]?.filter(({ id }) => id !== thread.id);
+          intents.push(
             createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.undo-delete',
-              properties: { threadId: thread.id, spaceId: space.id },
+              name: 'threads.thread-created',
+              properties: analyticsProperties,
             }),
-          ],
-        };
-      }
-    }),
-    createResolver(ThreadAction.OnMessageAdd, ({ thread, subject }) => {
-      const { state } = context.requestCapability(ThreadCapabilities.MutableState);
-      const subjectId = fullyQualifiedId(subject);
-      const space = getSpace(subject);
-      const intents = [];
-      const analyticsProperties = { threadId: thread.id, spaceId: space?.id };
-
-      if (state.drafts[subjectId]?.find((t) => t === thread)) {
-        // Move draft to document.
-        thread.status = 'active';
-        subject.threads ? subject.threads.push(makeRef(thread)) : (subject.threads = [makeRef(thread)]);
-        state.drafts[subjectId] = state.drafts[subjectId]?.filter(({ id }) => id !== thread.id);
+          );
+        }
+
         intents.push(
           createIntent(ObservabilityAction.SendEvent, {
-            name: 'threads.thread-created',
-            properties: analyticsProperties,
+            name: 'threads.message-added',
+            properties: { ...analyticsProperties, threadLength: thread.messages.length },
           }),
         );
-      }
 
-      intents.push(
-        createIntent(ObservabilityAction.SendEvent, {
-          name: 'threads.message-added',
-          properties: { ...analyticsProperties, threadLength: thread.messages.length },
-        }),
-      );
-
-      return { intents };
+        return { intents };
+      },
     }),
-    createResolver(ThreadAction.DeleteMessage, ({ subject, thread, messageId, message, messageIndex }, undo) => {
-      const space = getSpace(subject);
+    createResolver({
+      intent: ThreadAction.DeleteMessage,
+      resolve: ({ subject, thread, messageId, message, messageIndex }, undo) => {
+        const space = getSpace(subject);
+
+        if (!undo) {
+          const messageIndex = thread.messages.findIndex(Ref.hasObjectId(messageId));
+          const message = thread.messages[messageIndex]?.target;
+          if (!message) {
+            return;
+          }
 
-      if (!undo) {
-        const messageIndex = thread.messages.findIndex(Ref.hasObjectId(messageId));
-        const message = thread.messages[messageIndex]?.target;
-        if (!message) {
-          return;
-        }
+          if (messageIndex === 0 && thread.messages.length === 1) {
+            // If the message is the only message in the thread, delete the thread.
+            return {
+              intents: [createIntent(ThreadAction.Delete, { subject, thread })],
+            };
+          } else {
+            thread.messages.splice(messageIndex, 1);
+          }
 
-        if (messageIndex === 0 && thread.messages.length === 1) {
-          // If the message is the only message in the thread, delete the thread.
           return {
-            intents: [createIntent(ThreadAction.Delete, { subject, thread })],
+            undoable: {
+              message: ['message deleted label', { ns: THREAD_PLUGIN }],
+              data: { message, messageIndex },
+            },
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.message.delete',
+                properties: { threadId: thread.id, spaceId: space?.id },
+              }),
+            ],
           };
         } else {
-          thread.messages.splice(messageIndex, 1);
-        }
+          if (!messageIndex || !message) {
+            return;
+          }
 
-        return {
-          undoable: {
-            message: ['message deleted label', { ns: THREAD_PLUGIN }],
-            data: { message, messageIndex },
-          },
-          intents: [
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.message.delete',
-              properties: { threadId: thread.id, spaceId: space?.id },
-            }),
-          ],
-        };
-      } else {
-        if (!messageIndex || !message) {
-          return;
+          thread.messages.splice(messageIndex, 0, makeRef(message));
+          return {
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.message.undo-delete',
+                properties: { threadId: thread.id, spaceId: space?.id },
+              }),
+            ],
+          };
         }
-
-        thread.messages.splice(messageIndex, 0, makeRef(message));
-        return {
-          intents: [
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.message.undo-delete',
-              properties: { threadId: thread.id, spaceId: space?.id },
-            }),
-          ],
-        };
-      }
+      },
     }),
   ]);

package/src/capabilities/react-surface.tsx

@@ -4,8 +4,9 @@
 
 import React from 'react';
 
-import { Capabilities, contributes, createSurface, isLayoutParts, useCapability } from '@dxos/app-framework';
+import { Capabilities, contributes, createSurface, useLayout } from '@dxos/app-framework';
 import { type Ref } from '@dxos/echo-schema';
+import { SettingsStore } from '@dxos/local-storage';
 import { ChannelType, type ThreadType } from '@dxos/plugin-space/types';
 import { getSpace } from '@dxos/react-client/echo';
 
@@ -21,18 +22,14 @@ export default () =>
       filter: (data): data is { subject: ChannelType } =>
         data.subject instanceof ChannelType && !!data.subject.threads[0],
       component: ({ data, role }) => {
-        const location = useCapability(Capabilities.Location);
+        const layout = useLayout();
         const channel = data.subject;
         const thread = channel.threads[0].target!;
-        // TODO(zan): Maybe we should have utility for positional main object ids.
-        if (isLayoutParts(location?.active) && location.active.main) {
-          const layoutEntries = location.active.main;
-          const currentPosition = layoutEntries.findIndex((entry) => channel.id === entry.id);
-          if (currentPosition > 0) {
-            const objectToTheLeft = layoutEntries[currentPosition - 1];
-            const context = getSpace(channel)?.db.getObjectById(objectToTheLeft.id);
-            return <ThreadContainer role={role} thread={thread} context={context} />;
-          }
+        const currentPosition = layout.active.findIndex((id) => id === channel.id);
+        if (currentPosition > 0) {
+          const objectToTheLeft = layout.active[currentPosition - 1];
+          const context = getSpace(channel)?.db.getObjectById(objectToTheLeft);
+          return <ThreadContainer role={role} thread={thread} context={context} />;
         }
 
         return <ThreadContainer role={role} thread={thread} />;
@@ -51,11 +48,9 @@ export default () =>
     }),
     createSurface({
       id: `${THREAD_PLUGIN}/settings`,
-      role: 'settings',
-      filter: (data): data is any => data.subject === THREAD_PLUGIN,
-      component: () => {
-        const settings = useCapability(Capabilities.SettingsStore).getStore<ThreadSettingsProps>(THREAD_PLUGIN)!.value;
-        return <ThreadSettings settings={settings} />;
-      },
+      role: 'article',
+      filter: (data): data is { subject: SettingsStore<ThreadSettingsProps> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === THREAD_PLUGIN,
+      component: ({ data: { subject } }) => <ThreadSettings settings={subject.value} />,
     }),
   ]);

package/src/components/ThreadComplementary.tsx

@@ -4,7 +4,7 @@
 
 import React, { useCallback, useEffect, useMemo } from 'react';
 
-import { createIntent, LayoutAction, useCapabilities, useCapability, useIntentDispatcher } from '@dxos/app-framework';
+import { createIntent, LayoutAction, useCapability, useCapabilities, useIntentDispatcher } from '@dxos/app-framework';
 import { ThreadCapabilities } from '@dxos/plugin-space';
 import { MessageType, type ThreadType } from '@dxos/plugin-space/types';
 import { create, fullyQualifiedId, makeRef, RefArray } from '@dxos/react-client/echo';
@@ -62,9 +62,12 @@ export const ThreadComplementary = ({ subject }: { subject: any }) => {
         //  This may be overloading this intent or highjacking its intended purpose.
         void dispatch(
           createIntent(LayoutAction.ScrollIntoView, {
-            id: fullyQualifiedId(subject),
-            cursor: thread.anchor,
-            ref: threadId,
+            part: 'current',
+            subject: fullyQualifiedId(subject),
+            options: {
+              cursor: thread.anchor,
+              ref: threadId,
+            },
           }),
         );
       }

package/src/components/ThreadSettings.tsx

@@ -5,7 +5,7 @@
 import React from 'react';
 
 import { Input, useTranslation } from '@dxos/react-ui';
-import { DeprecatedFormInput } from '@dxos/react-ui-form';
+import { DeprecatedFormContainer, DeprecatedFormInput } from '@dxos/react-ui-form';
 
 import { THREAD_PLUGIN } from '../meta';
 import type { ThreadSettingsProps } from '../types';
@@ -14,10 +14,10 @@ export const ThreadSettings = ({ settings }: { settings: ThreadSettingsProps })
   const { t } = useTranslation(THREAD_PLUGIN);
 
   return (
-    <>
+    <DeprecatedFormContainer>
       <DeprecatedFormInput label={t('settings standalone label')}>
         <Input.Switch checked={settings.standalone} onCheckedChange={(checked) => (settings.standalone = !!checked)} />
       </DeprecatedFormInput>
-    </>
+    </DeprecatedFormContainer>
   );
 };

package/src/components/command-extension.ts

@@ -6,7 +6,7 @@ import { StreamLanguage, HighlightStyle, syntaxHighlighting } from '@codemirror/
 import { type Extension } from '@codemirror/state';
 
 import { tags } from '@dxos/react-ui-editor';
-import { mx, tagRoot } from '@dxos/react-ui-theme';
+import { mx } from '@dxos/react-ui-theme';
 
 /**
  * https://github.com/codemirror/stream-parser/blob/main/test/test-stream-parser.ts
@@ -27,10 +27,7 @@ const parser = StreamLanguage.define<{ count: number }>({
 });
 
 const styles = HighlightStyle.define([
-  {
-    tag: tags.tagName,
-    class: mx(tagRoot({ palette: 'cyan' }), 'text-baseText font-medium'),
-  },
+  { tag: tags.tagName, class: mx('dx-tag dx-tag--indigo text-baseText font-medium') },
 ]);
 
 export const command: Extension = [parser, syntaxHighlighting(styles)];