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

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];
+          // TODO(wittjosiah): Create separate intent for channel creation.
+          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,19 @@ 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} />;
-          }
+        void channel.threads[0].load();
+        const thread = channel.threads[0].target;
+        if (!thread) {
+          return null;
+        }
+
+        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 +53,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/Chat.stories.tsx

@@ -15,7 +15,6 @@ import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { withClientProvider } from '@dxos/react-client/testing';
-import { Mosaic } from '@dxos/react-ui-mosaic';
 import { Thread } from '@dxos/react-ui-thread';
 import { withLayout, withTheme } from '@dxos/storybook-utils';
 
@@ -47,10 +46,7 @@ const Story = () => {
   }
 
   return (
-    <Mosaic.Root debug>
-      <main className='max-is-prose mli-auto bs-dvh overflow-hidden'>{space && <ChatContainer thread={thread} />}</main>
-      <Mosaic.DragOverlay />
-    </Mosaic.Root>
+    <main className='max-is-prose mli-auto bs-dvh overflow-hidden'>{space && <ChatContainer thread={thread} />}</main>
   );
 };
 

package/src/components/ChatContainer.tsx

@@ -7,7 +7,7 @@ import React, { useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { Ref } from '@dxos/echo-schema';
 import { create, makeRef, RefArray } from '@dxos/live-object';
 import { MessageType } from '@dxos/plugin-space/types';
-import { fullyQualifiedId, getSpace, useMembers, type Expando } from '@dxos/react-client/echo';
+import { fullyQualifiedId, getSpace, useMembers } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Icon, ScrollArea, useThemeContext, useTranslation } from '@dxos/react-ui';
 import { createBasicExtensions, createThemeExtensions, listener } from '@dxos/react-ui-editor';
@@ -82,7 +82,7 @@ export const ChatContainer = ({ thread, context, current, autoFocusTextbox }: Th
           sender: { identityKey: identity.identityKey.toHex() },
           timestamp: new Date().toISOString(),
           text: messageRef.current,
-          context: makeRef(context as Expando),
+          context: context ? makeRef(context) : undefined,
         }),
       ),
     );

package/src/components/CommentContainer.tsx

@@ -18,7 +18,7 @@ import {
   mx,
 } from '@dxos/react-ui-theme';
 import { MessageTextbox, type MessageTextboxProps, Thread, ThreadFooter, ThreadHeading } from '@dxos/react-ui-thread';
-import { nonNullable } from '@dxos/util';
+import { isNonNullable } from '@dxos/util';
 
 import { MessageContainer } from './MessageContainer';
 import { command } from './command-extension';
@@ -179,7 +179,7 @@ export const CommentContainer = ({
         </div>
       </div>
       {/** TODO(dmaretskyi): How's `thread.messages` undefined? */}
-      {RefArray.allResolvedTargets(thread.messages?.filter(nonNullable) ?? []).map((message) => (
+      {RefArray.allResolvedTargets(thread.messages?.filter(isNonNullable) ?? []).map((message) => (
         <MessageContainer key={message.id} message={message} members={members} onDelete={handleMessageDelete} />
       ))}
       {/*

package/src/components/Comments.stories.tsx

@@ -44,7 +44,7 @@ const Story = ({ spaceKey }: ClientRepeatedComponentProps) => {
 
   return (
     <div className='flex justify-center overflow-y-auto bg-white dark:bg-black'>
-      <div className='flex flex-col w-[400px]'>
+      <div className='flex flex-col w-[30rem]'>
         <CommentsContainer threads={threads} detached={detached} onThreadDelete={console.log} />
       </div>
     </div>

package/src/components/MessageContainer.tsx

@@ -14,7 +14,6 @@ import { type ReactiveEchoObject, type Expando, type SpaceMember } from '@dxos/r
 import { useIdentity, type Identity } from '@dxos/react-client/halo';
 import { Button, ButtonGroup, Tooltip, useOnTransition, useThemeContext, useTranslation } from '@dxos/react-ui';
 import { createBasicExtensions, createThemeExtensions, useTextEditor } from '@dxos/react-ui-editor';
-import { Mosaic, type MosaicTileComponent } from '@dxos/react-ui-mosaic';
 import {
   getSize,
   hoverableControlItem,
@@ -26,7 +25,7 @@ import { MessageHeading, MessageRoot } from '@dxos/react-ui-thread';
 
 import { command } from './command-extension';
 import { useOnEditAnalytics } from '../hooks';
-import { THREAD_ITEM, THREAD_PLUGIN } from '../meta';
+import { THREAD_PLUGIN } from '../meta';
 import { getMessageMetadata } from '../util';
 
 // TODO(thure): #8149
@@ -109,11 +108,7 @@ export const MessageContainer = ({
 };
 
 const MessagePart = ({ part }: { part: Expando }) => {
-  return (
-    <Mosaic.Container id={part.id}>
-      <Mosaic.DraggableTile type={THREAD_ITEM} path={part.id} item={part} Component={MessageBlockObjectTile} />
-    </Mosaic.Container>
-  );
+  return <MessageBlockObjectTile subject={part} />;
 };
 
 const TextboxBlock = ({
@@ -165,9 +160,9 @@ const TextboxBlock = ({
   return <div role='none' ref={parentRef} className='mie-4' {...focusAttributes} />;
 };
 
-const MessageBlockObjectTile: MosaicTileComponent<ReactiveEchoObject<any>> = forwardRef(
-  ({ draggableStyle, draggableProps, item, active, ref: _ref, ...props }, forwardedRef) => {
-    let title = item.name ?? item.title ?? item.type ?? 'Object';
+const MessageBlockObjectTile = forwardRef<HTMLDivElement, { subject: ReactiveEchoObject<any> }>(
+  ({ subject }, forwardedRef) => {
+    let title = subject.name ?? subject.title ?? subject.type ?? 'Object';
     if (typeof title !== 'string') {
       title = title?.content ?? '';
     }
@@ -176,17 +171,9 @@ const MessageBlockObjectTile: MosaicTileComponent<ReactiveEchoObject<any>> = for
       <div
         role='group'
         className={mx('grid col-span-3 py-1 pr-4', hoverableControls, hoverableFocusedWithinControls)}
-        style={draggableStyle}
         ref={forwardedRef}
       >
-        <Surface
-          role='card'
-          limit={1}
-          data={{ subject: item }}
-          draggableProps={draggableProps}
-          fallback={title}
-          {...props}
-        />
+        <Surface role='card' limit={1} data={{ subject }} fallback={title} />
       </div>
     );
   },

package/src/components/ThreadComplementary.tsx

@@ -4,13 +4,13 @@
 
 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';
 import { useIdentity } from '@dxos/react-client/halo';
 import { useAttended } from '@dxos/react-ui-attention';
-import { nonNullable } from '@dxos/util';
+import { isNonNullable } from '@dxos/util';
 
 import { ThreadCapabilities as LocalThreadCapabilities } from '../capabilities';
 import { CommentsContainer } from '../components';
@@ -34,7 +34,7 @@ export const ThreadComplementary = ({ subject }: { subject: any }) => {
   const threadObjects = RefArray.allResolvedTargets(subject.threads ?? []);
 
   const threads = useMemo(() => {
-    return threadObjects.concat(drafts ?? []).filter(nonNullable) as ThreadType[];
+    return threadObjects.concat(drafts ?? []).filter(isNonNullable) as ThreadType[];
   }, [JSON.stringify(threadObjects), JSON.stringify(drafts)]);
 
   const detachedIds = useMemo(() => {
@@ -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

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