@dxos/plugin-thread 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/extensions/threads.ts

@@ -1,171 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type Extension } from '@codemirror/state';
-import { EditorView } from '@codemirror/view';
-import { type Atom, type Registry } from '@effect-atom/atom-react';
-
-import { Filter, Obj, Query, Relation } from '@dxos/echo';
-import { createDocAccessor, getTextInRange } from '@dxos/echo-db';
-import { type OperationInvoker } from '@dxos/operation';
-import { type Markdown } from '@dxos/plugin-markdown/types';
-import { AnchoredTo, Thread } from '@dxos/types';
-import { comments, createExternalCommentSync } from '@dxos/ui-editor';
-
-import { ThreadOperation } from '#operations';
-import { type ThreadState } from '#types';
-
-// TODO(burdon): Factor out.
-const getName = (doc: Markdown.Document, anchor: string): string | undefined => {
-  if (doc.content) {
-    const [start, end] = anchor.split(':');
-    return getTextInRange(createDocAccessor(doc.content.target!, ['content']), start, end);
-  }
-};
-
-export type ThreadStore = {
-  registry: Registry.Registry;
-  stateAtom: Atom.Writable<ThreadState>;
-};
-
-/**
- * Construct plugins.
- */
-export const threads = (
-  store: ThreadStore,
-  doc?: Markdown.Document,
-  invokePromise?: OperationInvoker.OperationInvoker['invokePromise'],
-): Extension => {
-  const db = doc && Obj.getDatabase(doc);
-  if (!doc || !db || !invokePromise) {
-    // Include no-op comments extension here to ensure that the facets are always present when they are expected.
-    // TODO(wittjosiah): The Editor should only look for these facets when comments are available.
-    return [comments()];
-  }
-
-  const { registry, stateAtom } = store;
-  const objectId = Obj.getDXN(doc).toString();
-  const query = db.query(Query.select(Filter.id(doc.id)).targetOf(AnchoredTo.AnchoredTo));
-
-  // Get current anchors by combining query results with store drafts.
-  const getAnchors = () =>
-    query.results
-      .filter((anchor) => {
-        const thread = Relation.getSource(anchor);
-        return Obj.instanceOf(Thread.Thread, thread) && thread.status !== 'resolved';
-      })
-      .concat(registry.get(stateAtom).drafts[objectId] ?? []);
-
-  return [
-    EditorView.domEventHandlers({
-      destroy: () => {
-        // Note: cleanup functions for subscriptions are handled by createExternalCommentSync.
-      },
-    }),
-
-    EditorView.updateListener.of((update) => {
-      if (update.docChanged) {
-        getAnchors().forEach((anchor) => {
-          if (anchor.anchor) {
-            // Only update if the name has changed, otherwise this will cause an infinite loop.
-            // Skip if the name is empty; this means comment text was deleted, but thread name should remain.
-            const name = getName(doc, anchor.anchor);
-            const thread = Relation.getSource(anchor) as Thread.Thread;
-            if (name && name !== thread.name) {
-              Obj.change(thread, (thread) => {
-                thread.name = name;
-              });
-            }
-          }
-        });
-      }
-    }),
-
-    createExternalCommentSync(
-      objectId,
-      (sink) => {
-        // Subscribe to both query changes and store state changes.
-        const unsubQuery = query.subscribe(sink);
-        const unsubStore = registry.subscribe(stateAtom, sink);
-        return () => {
-          unsubQuery();
-          unsubStore();
-        };
-      },
-      () =>
-        getAnchors()
-          .filter((anchor) => anchor.anchor)
-          .map((anchor) => ({
-            id: Obj.getDXN(Relation.getSource(anchor)).toString(),
-            cursor: anchor.anchor,
-          })),
-    ),
-
-    comments({
-      id: objectId,
-      onCreate: ({ cursor }) => {
-        const name = getName(doc, cursor);
-        void invokePromise(ThreadOperation.Create, {
-          anchor: cursor,
-          name,
-          subject: doc,
-        });
-      },
-      onDelete: ({ id }) => {
-        const drafts = registry.get(stateAtom).drafts[objectId];
-        if (drafts) {
-          const index = drafts.findIndex((draft) => Relation.getDXN(draft).toString() === id);
-          if (index !== -1) {
-            const current = registry.get(stateAtom);
-            registry.set(stateAtom, {
-              ...current,
-              drafts: {
-                ...current.drafts,
-                [objectId]: current.drafts[objectId]?.filter((_, i) => i !== index),
-              },
-            });
-          }
-        }
-
-        const thread = query.results.find((object) => Relation.getSource(object).id === id);
-        if (thread) {
-          Relation.change(thread, (thread) => {
-            thread.anchor = undefined;
-          });
-        }
-      },
-      onUpdate: ({ id, cursor }) => {
-        const draft = registry.get(stateAtom).drafts[objectId]?.find((d) => Relation.getDXN(d).toString() === id);
-        if (draft) {
-          const thread = Relation.getSource(draft) as Thread.Thread;
-          Obj.change(thread, (thread) => {
-            thread.name = getName(doc, cursor);
-          });
-          Relation.change(draft, (draft) => {
-            draft.anchor = cursor;
-          });
-        }
-
-        const relation = query.results.find((object) => Relation.getSource(object).id === id);
-        if (relation) {
-          const thread = Relation.getSource(relation);
-          if (Obj.instanceOf(Thread.Thread, thread)) {
-            Obj.change(thread, (thread) => {
-              thread.name = getName(doc, cursor);
-            });
-            Relation.change(relation, (relation) => {
-              relation.anchor = cursor;
-            });
-          }
-        }
-      },
-      onSelect: ({ selection }) => {
-        const current = selection.current ?? selection.closest;
-        if (current) {
-          void invokePromise(ThreadOperation.Select, { current });
-        }
-      },
-    }),
-  ];
-};

package/src/hooks/analytics.ts

@@ -1,41 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { useCallback } from 'react';
-
-import { useOperationInvoker } from '@dxos/app-framework/ui';
-import { Obj } from '@dxos/echo';
-import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
-import { useOnTransition } from '@dxos/react-ui';
-import { type ContentBlock } from '@dxos/types';
-
-export const useOnEditAnalytics = (
-  message: any | undefined,
-  textBlock: ContentBlock.Text | undefined,
-  editing: boolean,
-) => {
-  const { invokePromise } = useOperationInvoker();
-
-  const onEdit = useCallback(() => {
-    if (!message || !textBlock) {
-      return;
-    }
-
-    const db = Obj.getDatabase(message);
-    if (!db) {
-      return;
-    }
-
-    void invokePromise(ObservabilityOperation.SendEvent, {
-      name: 'threads.message.update',
-      properties: {
-        spaceId: db.spaceId,
-        messageId: message.id,
-        messageLength: textBlock?.text.length,
-      },
-    });
-  }, [invokePromise, message, textBlock]);
-
-  useOnTransition(editing, true, false, onEdit);
-};

package/src/hooks/useBlackCanvasStreamTrack.tsx

@@ -1,27 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useEffect, useState } from 'react';
-
-import { scheduleTask } from '@dxos/async';
-import { Context } from '@dxos/context';
-
-import { createBlackCanvasStreamTrack } from '../calls/util/stub-media-streams';
-
-export const useBlackCanvasStreamTrack = () => {
-  const [blackCanvasStreamTrack, setBlackCanvasStreamTrack] = useState<MediaStreamTrack | undefined>(undefined);
-  useEffect(() => {
-    const ctx = new Context();
-    scheduleTask(ctx, async () => {
-      const blackCanvasStreamTrack = await createBlackCanvasStreamTrack({ ctx, width: 720, height: 480 });
-      setBlackCanvasStreamTrack(blackCanvasStreamTrack);
-    });
-
-    return () => {
-      void ctx.dispose();
-    };
-  }, []);
-
-  return blackCanvasStreamTrack;
-};

package/src/hooks/useDebugMode.ts

@@ -1,25 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useEffect, useState } from 'react';
-
-// TODO(burdon): Standardize across plugins/composer.
-export const useDebugMode = () => {
-  const [enabled, setEnabled] = useState(false);
-  useEffect(() => {
-    const handler = (ev: KeyboardEvent) => {
-      if (ev.key.toLowerCase() === 'd' && ev.ctrlKey) {
-        ev.preventDefault();
-        setEnabled(!enabled);
-      }
-    };
-
-    document.addEventListener('keypress', handler);
-    return () => {
-      document.removeEventListener('keypress', handler);
-    };
-  }, [enabled]);
-
-  return enabled;
-};

package/src/hooks/useInaudibleAudioStreamTrack.tsx

@@ -1,27 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useEffect, useState } from 'react';
-
-import { scheduleTask } from '@dxos/async';
-import { Context } from '@dxos/context';
-
-import { createInaudibleAudioStreamTrack } from '../calls/util/stub-media-streams';
-
-export const useInaudibleAudioStreamTrack = () => {
-  const [audioStreamTrack, setAudioStreamTrack] = useState<MediaStreamTrack | undefined>(undefined);
-  useEffect(() => {
-    const ctx = new Context();
-    scheduleTask(ctx, async () => {
-      const audioStreamTrack = await createInaudibleAudioStreamTrack({ ctx });
-      setAudioStreamTrack(audioStreamTrack);
-    });
-
-    return () => {
-      void ctx.dispose();
-    };
-  }, []);
-
-  return audioStreamTrack;
-};

package/src/hooks/useVideoStreamTrack.tsx

@@ -1,36 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type RefObject, useEffect, useRef, useState } from 'react';
-
-export const useVideoStreamTrack = (videoElement: RefObject<HTMLVideoElement | null>, videoSrc: string) => {
-  // Get video stream track.
-  const [videoStreamTrack, setVideoStreamTrack] = useState<MediaStreamTrack | undefined>(undefined);
-  const hadRun = useRef(false);
-  useEffect(() => {
-    // This is done to capture only one video stream.
-    if (!videoElement.current || hadRun.current || !videoSrc) {
-      return;
-    }
-    hadRun.current = true;
-    videoElement.current.addEventListener('playing', () => {
-      if (videoStreamTrack) {
-        return;
-      }
-      const stream = (videoElement.current as any).captureStream();
-      const track = stream.getTracks()[0];
-      if (track && !videoStreamTrack) {
-        setVideoStreamTrack(track);
-      }
-      stream.onaddtrack = (event: MediaStreamTrackEvent) => {
-        if (event.track.kind === 'video' && !videoStreamTrack) {
-          setVideoStreamTrack(event.track);
-        }
-      };
-    });
-    videoElement.current.src = videoSrc;
-  }, [videoElement.current, videoSrc]);
-
-  return videoStreamTrack;
-};

package/src/operations/add-message.ts

@@ -1,81 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { Obj, Ref, Relation } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { Operation } from '@dxos/operation';
-import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
-import { SpaceOperation } from '@dxos/plugin-space/operations';
-import { AnchoredTo, Message, Thread } from '@dxos/types';
-
-import { ThreadCapabilities } from '../types';
-import { AddMessage } from './definitions';
-
-const handler: Operation.WithHandler<typeof AddMessage> = AddMessage.pipe(
-  Operation.withHandler(
-    Effect.fnUntraced(function* ({ anchor, subject, sender, text }) {
-      const registry = yield* Capability.get(Capabilities.AtomRegistry);
-      const stateAtom = yield* Capability.get(ThreadCapabilities.State);
-      const thread = Relation.getSource(anchor) as Thread.Thread;
-      const subjectId = Obj.getDXN(subject).toString();
-      const db = Obj.getDatabase(subject);
-      invariant(db, 'Database not found');
-
-      const message = Obj.make(Message.Message, {
-        created: new Date().toISOString(),
-        sender,
-        blocks: [{ _tag: 'text', text }],
-      });
-      Obj.change(thread, (thread) => {
-        thread.messages.push(Ref.make(message));
-      });
-
-      const state = registry.get(stateAtom);
-      const draft = state.drafts[subjectId]?.find((a: { id: string }) => a.id === anchor.id);
-      if (draft) {
-        Obj.change(thread, (thread) => {
-          thread.status = 'active';
-        });
-        registry.set(stateAtom, {
-          ...state,
-          drafts: {
-            ...state.drafts,
-            [subjectId]: state.drafts[subjectId]?.filter((a: { id: string }) => a.id !== anchor.id),
-          },
-        });
-        yield* Operation.invoke(SpaceOperation.AddObject, { object: thread, target: db, hidden: true });
-        yield* Operation.invoke(SpaceOperation.AddRelation, {
-          db,
-          schema: AnchoredTo.AnchoredTo,
-          source: thread,
-          target: subject,
-          fields: { anchor: draft.anchor },
-        });
-        yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-          name: 'threads.create',
-          properties: {
-            spaceId: db.spaceId,
-            threadId: thread.id,
-          },
-        });
-      }
-
-      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-        name: 'threads.message.add',
-        properties: {
-          spaceId: db.spaceId,
-          threadId: thread.id,
-          threadLength: thread.messages.length,
-          messageId: message.id,
-          messageLength: text.length,
-        },
-      });
-    }),
-  ),
-);
-
-export default handler;

package/src/operations/create-channel-thread.ts

@@ -1,26 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Obj, Ref } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
-import { Thread } from '@dxos/types';
-
-import { CreateChannelThread } from './definitions';
-
-const handler: Operation.WithHandler<typeof CreateChannelThread> = CreateChannelThread.pipe(
-  Operation.withHandler((input) =>
-    Effect.sync(() => {
-      const thread = Thread.make({ status: 'active' });
-      const threadRef = Ref.make(thread);
-      Obj.change(input.channel, (obj) => {
-        obj.threads.push(threadRef);
-      });
-      return { object: thread };
-    }),
-  ),
-);
-
-export default handler;

package/src/operations/create-proposals.ts

@@ -1,49 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Array from 'effect/Array';
-import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
-
-import { computeDiffsWithCursors } from '@dxos/assistant';
-import { Database, Obj, Ref, Relation } from '@dxos/echo';
-import { createDocAccessor } from '@dxos/echo-db';
-import { Operation } from '@dxos/operation';
-import { AnchoredTo, Message, Thread } from '@dxos/types';
-
-import { CreateProposals } from './definitions';
-
-const handler: Operation.WithHandler<typeof CreateProposals> = CreateProposals.pipe(
-  Operation.withHandler(
-    Effect.fn(function* ({ doc, diffs }) {
-      const object = yield* Database.load(doc);
-      const content = yield* Effect.promise(() => object.content.load());
-      const accessor = createDocAccessor(content, ['content']);
-
-      yield* Function.pipe(
-        computeDiffsWithCursors(accessor, diffs),
-        Array.map(
-          Effect.fnUntraced(function* ({ cursor, text }) {
-            const proposal = Obj.make(Message.Message, {
-              created: new Date().toISOString(),
-              sender: { role: 'assistant' },
-              blocks: [{ _tag: 'proposal', text }],
-            });
-            const thread = Thread.make({ name: 'Proposal', messages: [Ref.make(proposal)], status: 'active' });
-            const relation = Relation.make(AnchoredTo.AnchoredTo, {
-              [Relation.Source]: thread,
-              [Relation.Target]: object,
-              anchor: cursor,
-            });
-            yield* Database.add(thread);
-            yield* Database.add(relation);
-          }),
-        ),
-        Effect.allWith({ concurrency: 'unbounded' }),
-      );
-    }),
-  ),
-);
-
-export default handler;

package/src/operations/create.ts

@@ -1,48 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { Obj, Relation } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
-import { DeckOperation } from '@dxos/plugin-deck/operations';
-import { linkedSegment } from '@dxos/react-ui-attention';
-import { AnchoredTo, Thread } from '@dxos/types';
-
-import { ThreadCapabilities } from '../types';
-import { Create, Select } from './definitions';
-
-const handler: Operation.WithHandler<typeof Create> = Create.pipe(
-  Operation.withHandler(
-    Effect.fnUntraced(function* ({ name, anchor: _anchor, subject }) {
-      const registry = yield* Capability.get(Capabilities.AtomRegistry);
-      const stateAtom = yield* Capability.get(ThreadCapabilities.State);
-      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 state = registry.get(stateAtom);
-      const existingDrafts = state.drafts[subjectId];
-      registry.set(stateAtom, {
-        ...state,
-        drafts: {
-          ...state.drafts,
-          [subjectId]: existingDrafts ? [...existingDrafts, anchor] : [anchor],
-        },
-      });
-
-      yield* Operation.invoke(Select, { current: Obj.getDXN(thread).toString() });
-      yield* Operation.invoke(DeckOperation.ChangeCompanion, {
-        companion: linkedSegment('comments'),
-      });
-    }),
-  ),
-);
-
-export default handler;