@dxos/plugin-thread 0.8.4-main.e8ec1fe → 0.8.4-main.effb148878

package/src/capabilities/intent-resolver.ts

@@ -1,311 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
-import { sleep } from '@dxos/async';
-import { Obj, Relation, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { ObservabilityAction } from '@dxos/plugin-observability/types';
-import { CollectionAction, SpaceAction } from '@dxos/plugin-space/types';
-import { Ref, getSpace } from '@dxos/react-client/echo';
-import { AnchoredTo, Message, Thread } from '@dxos/types';
-
-import { meta } from '../meta';
-import { Channel, ThreadAction } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: ThreadAction.onCreateSpace,
-      resolve: ({ space, rootCollection }) =>
-        Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(Channel.Channel) }),
-          );
-          rootCollection.objects.push(Ref.make(collection));
-
-          const { object: channel } = yield* dispatch(
-            createIntent(ThreadAction.CreateChannel, { name: 'General', spaceId: space.id }),
-          );
-          space.db.add(channel);
-        }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannel,
-      resolve: ({ name }) => ({
-        data: {
-          object: Channel.make({ name }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannelThread,
-      resolve: ({ channel }) => {
-        const thread = Thread.make({ status: 'active' });
-        channel.threads.push(Ref.make(thread));
-        return {
-          data: {
-            object: thread,
-          },
-        };
-      },
-    }),
-    // TODO(wittjosiah): Break this up into more composable pieces.
-    createResolver({
-      intent: ThreadAction.Create,
-      resolve: ({ name, anchor: _anchor, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        const thread = Thread.make({ name });
-        const anchor = Relation.make(AnchoredTo.AnchoredTo, {
-          [Relation.Source]: thread,
-          [Relation.Target]: subject,
-          anchor: _anchor,
-        });
-
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          draft.push(anchor);
-        } else {
-          state.drafts[subjectId] = [anchor];
-        }
-
-        return {
-          intents: [
-            createIntent(ThreadAction.Select, { current: Obj.getDXN(thread).toString() }),
-            createIntent(DeckAction.ChangeCompanion, {
-              primary: subjectId,
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Select,
-      resolve: ({ current }) => {
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        state.current = current;
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.ToggleResolved,
-      resolve: ({ thread }) => {
-        if (thread.status === 'active' || thread.status === undefined) {
-          thread.status = 'resolved';
-        } else if (thread.status === 'resolved') {
-          thread.status = 'active';
-        }
-
-        const space = getSpace(thread);
-        invariant(space, 'Space not found');
-        const spaceId = space.id;
-
-        return {
-          intents: [
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.toggle-resolved',
-              properties: {
-                spaceId,
-                threadId: thread.id,
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Delete,
-      resolve: async ({ subject, anchor, thread: _thread }, undo) => {
-        const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          // Check if we're deleting a draft; if so, remo ve it.
-          const index = draft.findIndex((a) => a.id === anchor.id);
-          if (index !== -1) {
-            draft.splice(index, 1);
-            return;
-          }
-        }
-
-        const space = getSpace(anchor);
-        if (!space) {
-          return;
-        }
-
-        if (!undo) {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.remove(anchor);
-          await sleep(100);
-          space.db.remove(thread);
-
-          return {
-            undoable: {
-              message: ['thread deleted label', { ns: meta.id }],
-              data: { thread, anchor },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.add(thread);
-          await sleep(100);
-          space.db.add(anchor);
-
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.AddMessage,
-      resolve: ({ anchor, subject, sender, text }) => {
-        const thread = Relation.getSource(anchor) as Thread.Thread;
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = Obj.getDXN(subject).toString();
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const message = Obj.make(Message.Message, {
-          created: new Date().toISOString(),
-          sender,
-          blocks: [{ _tag: 'text', text }],
-          // TODO(wittjosiah): Context based on attention.
-          // context: context ? Ref.make(context) : undefined,
-        });
-        thread.messages.push(Ref.make(message));
-
-        const intents = [];
-        const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
-        if (draft) {
-          // Move draft to document.
-          thread.status = 'active';
-          // TODO(wittjosiah): This causes the thread to flash as it transitions from draft to db.
-          state.drafts[subjectId] = state.drafts[subjectId]?.filter((a) => a.id !== anchor.id);
-          intents.push(createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }));
-          intents.push(
-            createIntent(SpaceAction.AddRelation, {
-              space,
-              schema: AnchoredTo.AnchoredTo,
-              source: thread,
-              target: subject,
-              fields: { anchor: draft.anchor },
-            }),
-          );
-          intents.push(
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.create',
-              properties: {
-                spaceId: space.id,
-                threadId: thread.id,
-              },
-            }),
-          );
-        }
-
-        intents.push(
-          createIntent(ObservabilityAction.SendEvent, {
-            name: 'threads.message.add',
-            properties: {
-              spaceId: space.id,
-              threadId: thread.id,
-              threadLength: thread.messages.length,
-              messageId: message.id,
-              messageLength: text.length,
-            },
-          }),
-        );
-
-        return { intents };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.DeleteMessage,
-      resolve: ({ subject, anchor, messageId, message, messageIndex }, undo) => {
-        const thread = Relation.getSource(anchor) as Thread.Thread;
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        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, anchor })],
-            };
-          } else {
-            thread.messages.splice(messageIndex, 1);
-          }
-
-          return {
-            undoable: {
-              message: ['message deleted label', { ns: meta.id }],
-              data: { message, messageIndex },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          if (messageIndex === undefined || !message) {
-            return;
-          }
-
-          thread.messages.splice(messageIndex, 0, Ref.make(message));
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-  ]);

package/src/capabilities/react-root.tsx

@@ -1,17 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities, contributes } from '@dxos/app-framework';
-
-import { Call } from '../components';
-import { meta } from '../meta';
-
-export default () => {
-  return contributes(Capabilities.ReactRoot, {
-    id: meta.id,
-    root: () => <Call.Audio />,
-  });
-};

package/src/components/Call/Call.tsx

@@ -1,89 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React, { type FC, type PropsWithChildren } from 'react';
-
-import { useCapability } from '@dxos/app-framework/react';
-import { type ThemedClassName } from '@dxos/react-ui';
-
-import { ThreadCapabilities } from '../../capabilities';
-import { useDebugMode } from '../../hooks';
-import { AudioStream } from '../Media';
-import { ParticipantGrid } from '../Participant';
-
-import { Toolbar, type ToolbarProps } from './Toolbar';
-
-//
-// Root
-//
-
-type CallRootProps = PropsWithChildren<ThemedClassName>;
-
-const CallRoot: FC<CallRootProps> = ({ children }) => {
-  return <div className='relative flex flex-col grow overflow-hidden'>{children}</div>;
-};
-
-CallRoot.displayName = 'CallRoot';
-
-//
-// Audio
-//
-
-type CallAudioProps = {};
-
-const CallAudio: FC<CallAudioProps> = () => {
-  const call = useCapability(ThreadCapabilities.CallManager);
-
-  return <AudioStream tracks={call.audioTracksToPlay} />;
-};
-
-CallAudio.displayName = 'CallAudio';
-
-//
-// Room
-//
-
-type CallGridProps = {
-  fullscreen?: boolean;
-};
-
-const CallGrid: FC<CallGridProps> = ({ fullscreen }) => {
-  const debug = useDebugMode();
-  const call = useCapability(ThreadCapabilities.CallManager);
-
-  return (
-    <div className='grid grow p-4 dark:bg-neutral-900'>
-      <ParticipantGrid self={call.self} users={call.users} debug={debug} fullscreen={fullscreen} />
-    </div>
-  );
-};
-
-CallGrid.displayName = 'CallGrid';
-
-//
-// Toolbar
-//
-
-type CallToolbarProps = Pick<ToolbarProps, 'channel' | 'onLeave'>;
-
-const CallToolbar: FC<CallToolbarProps> = (props) => {
-  return (
-    <div className='absolute bottom-0 left-0 right-0 flex justify-center'>
-      <Toolbar isInRoom {...props} />
-    </div>
-  );
-};
-
-CallToolbar.displayName = 'CallToolbar';
-
-//
-// Export
-//
-
-export const Call = {
-  Root: CallRoot,
-  Grid: CallGrid,
-  Audio: CallAudio,
-  Toolbar: CallToolbar,
-};

package/src/components/Call/Toolbar.tsx

@@ -1,182 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React from 'react';
-
-import { useAppGraph, useCapability } from '@dxos/app-framework/react';
-import { Obj } from '@dxos/echo';
-import { useActions, useNode } from '@dxos/plugin-graph';
-import {
-  Icon,
-  IconButton,
-  type IconButtonProps,
-  Toolbar as NaturalToolbar,
-  type ThemedClassName,
-  toLocalizedString,
-  useTranslation,
-} from '@dxos/react-ui';
-import { groupHoverControlItemWithTransition, mx } from '@dxos/react-ui-theme';
-
-import { ThreadCapabilities } from '../../capabilities';
-import { meta } from '../../meta';
-import { type Channel } from '../../types';
-
-export type ToolbarProps = ThemedClassName<{
-  channel?: Channel.Channel;
-  participants?: number;
-  autoHideControls?: boolean;
-  isInRoom?: boolean;
-  onJoin?: () => void;
-  onLeave?: () => void;
-}>;
-
-// TODO(wittjosiah): Use ToolbarMenu.
-export const Toolbar = ({
-  classNames,
-  channel,
-  participants,
-  autoHideControls = true,
-  onJoin,
-  onLeave,
-}: ToolbarProps) => {
-  const { t } = useTranslation(meta.id);
-  const { graph } = useAppGraph();
-  const call = useCapability(ThreadCapabilities.CallManager);
-
-  // Channel app graph node.
-  const node = useNode(graph, channel && Obj.getDXN(channel).toString());
-  const actions = useActions(graph, node?.id).filter((action) => action.properties.disposition === 'toolbar');
-
-  // Screen sharing.
-  const isScreensharing = call.media.screenshareTrack !== undefined;
-  const canSharescreen =
-    typeof navigator.mediaDevices !== 'undefined' && navigator.mediaDevices.getDisplayMedia !== undefined;
-
-  // TODO(wittjosiah): In order to use toolbar, need to update to actually use the graph action callbacks directly.
-  return (
-    <div className={mx('z-20 flex justify-center m-8', autoHideControls && groupHoverControlItemWithTransition)}>
-      <NaturalToolbar.Root classNames={['p-2 bg-modalSurface rounded-md shadow-md', classNames]}>
-        <ToggleButton
-          active={call.media.audioEnabled}
-          state={{
-            on: {
-              icon: 'ph--microphone--regular',
-              label: t('mic off'),
-              onClick: () => call.turnAudioOff(),
-              classNames: 'bg-callActive',
-            },
-            off: {
-              icon: 'ph--microphone-slash--duotone',
-              label: t('mic on'),
-              onClick: () => call.turnAudioOn(),
-              classNames: [call.joined && 'bg-callAlert'],
-            },
-          }}
-        />
-        <ToggleButton
-          active={call.media.videoEnabled}
-          state={{
-            on: {
-              icon: 'ph--video-camera--regular',
-              label: t('camera off'),
-              onClick: () => call.turnVideoOff(),
-            },
-            off: {
-              icon: 'ph--video-camera-slash--duotone',
-              label: t('camera on'),
-              onClick: () => call.turnVideoOn(),
-            },
-          }}
-        />
-
-        {(participants !== undefined && (
-          <div className='flex justify-center items-center gap-2 is-[5rem] text-xs text-subdued'>
-            <Icon icon='ph--users--regular' size={4} />
-            <div>{participants}</div>
-          </div>
-        )) || <NaturalToolbar.Separator variant='gap' />}
-
-        {call.joined && (
-          <>
-            <ToggleButton
-              disabled={!canSharescreen}
-              active={isScreensharing}
-              state={{
-                on: {
-                  icon: 'ph--monitor--regular',
-                  label: t('screenshare off'),
-                  onClick: () => call.turnScreenshareOff(),
-                },
-                off: {
-                  icon: 'ph--monitor-arrow-up--duotone',
-                  label: t('screenshare on'),
-                  onClick: () => call.turnScreenshareOn(),
-                },
-              }}
-            />
-
-            {/* Companion actions. */}
-            {actions.map((action) => (
-              <IconButton
-                key={action.id}
-                {...defaultButtonProps}
-                icon={action.properties.icon}
-                label={toLocalizedString(action.properties.label, t)}
-                classNames={action.properties.classNames}
-                onClick={() => action.data({ node })}
-              />
-            ))}
-
-            <ToggleButton
-              active={call.raisedHand}
-              state={{
-                on: {
-                  icon: 'ph--hand-waving--regular',
-                  label: t('lower hand'),
-                  onClick: () => call.setRaisedHand(false),
-                  classNames: [call.joined && 'bg-callAlert'],
-                },
-                off: {
-                  icon: 'ph--hand-palm--duotone',
-                  label: t('raise hand'),
-                  onClick: () => call.setRaisedHand(true),
-                },
-              }}
-            />
-          </>
-        )}
-        {call.joined ? (
-          <IconButton variant='destructive' icon='ph--phone-x--regular' label={t('leave call')} onClick={onLeave} />
-        ) : (
-          <IconButton variant='primary' icon='ph--phone-incoming--regular' label={t('join call')} onClick={onJoin} />
-        )}
-      </NaturalToolbar.Root>
-    </div>
-  );
-};
-
-Toolbar.displayName = 'MeetingToolbar';
-
-type ToolbarButtonProps = Pick<IconButtonProps, 'disabled'> & {
-  active?: boolean;
-  state: {
-    on: Pick<IconButtonProps, 'icon' | 'label' | 'onClick' | 'classNames'>;
-    off: Pick<IconButtonProps, 'icon' | 'label' | 'onClick' | 'classNames'>;
-  };
-};
-
-const defaultButtonProps: Partial<IconButtonProps> = {
-  size: 5,
-  iconOnly: true,
-};
-
-const ToggleButton = ({ active, state }: ToolbarButtonProps) => (
-  <IconButton
-    {...defaultButtonProps}
-    classNames={[active ? (state.on.classNames ?? 'bg-callActive') : state.off.classNames]}
-    icon={active ? state.on.icon : state.off.icon}
-    label={active ? state.on.label : state.off.label}
-    onClick={active ? state.on.onClick : state.off.onClick}
-  />
-);

package/src/components/Call/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './Call';
-export * from './Toolbar';