@dxos/plugin-transcription 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/components/Transcript/deprecated/OldTranscript.tsx

@@ -1,260 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { intervalToDuration } from 'date-fns/intervalToDuration';
-import * as Schema from 'effect/Schema';
-import { yieldOrContinue } from 'main-thread-scheduling';
-import React, { type FC, type WheelEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { type OnResizeCallback, useResizeDetector } from 'react-resize-detector';
-
-import { Type } from '@dxos/echo';
-import { IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
-import { useAttention } from '@dxos/react-ui-attention';
-import {
-  type DxGridAxisMeta,
-  type DxGridCellValue,
-  type DxGridElement,
-  type DxGridPlaneCells,
-  Grid,
-  toPlaneCellIndex,
-} from '@dxos/react-ui-grid';
-import { mx } from '@dxos/react-ui-theme';
-
-import { meta } from '../../../meta';
-
-/**
- * Transcription fragment.
- */
-const TranscriptSegment = Schema.Struct({
-  // TODO(burdon): TS from service is not Unix TS (x1000).
-  started: Schema.String,
-  text: Schema.String,
-});
-
-type TranscriptSegment = Schema.Schema.Type<typeof TranscriptSegment>;
-
-/**
- * Transcription block (from single speaker).
- */
-const TranscriptBlock = Schema.Struct({
-  id: Schema.String,
-  authorName: Schema.optional(Schema.String), // TODO(burdon): Replace with identityDid.
-  authorHue: Schema.optional(Schema.String), // TOOD(burdon): Remove.
-  segments: Schema.Array(TranscriptSegment),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/TranscriptBlock',
-    version: '0.1.0',
-  }),
-);
-
-type TranscriptBlock = Schema.Schema.Type<typeof TranscriptBlock>;
-
-// TODO(burdon): Actions (e.g., mark, summarize, translate, label, delete).
-
-const lineHeight = 20;
-const cellSpacing = 8 + 2;
-const timestampColumnWidth = 68;
-
-const authorClasses = 'font-medium text-base leading-[20px]';
-const timestampClasses = 'text-xs leading-[20px] text-description pie-0 tabular-nums';
-const segmentTextClasses = 'text-sm whitespace-normal hyphens-auto';
-const measureClasses = mx(
-  // NOTE(thure): The `inline-start` value must equal `timestampColumnWidth` plus grid’s gap (1px)
-  'absolute inline-start-[69px] inline-end-0 invisible z-[-1] border',
-  'pli-[--dx-grid-cell-padding-inline] plb-[--dx-grid-cell-padding-block] leading-[20px]',
-  segmentTextClasses,
-);
-
-const rowDefault = {
-  grid: { size: lineHeight + cellSpacing },
-};
-
-type QueueRows = [number, number][];
-
-const mapTranscriptQueue = (blocks?: TranscriptBlock[]): QueueRows => {
-  if (!blocks || !Array.isArray(blocks) || blocks.length === 0) {
-    return [];
-  } else {
-    return blocks.flatMap((block, blockIndex) => {
-      return [
-        [blockIndex, -1],
-        ...block.segments.map((segment, segmentIndex) => {
-          return [blockIndex, segmentIndex] as [number, number];
-        }),
-      ];
-    });
-  }
-};
-
-const pad = (n = 0) => String(n).padStart(2, '0');
-
-const formatTimestamp = (start: Date, end: Date) => {
-  const { hours, minutes, seconds } = intervalToDuration({ start, end });
-  return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
-};
-
-const measureRows = async (
-  host: HTMLDivElement,
-  blocks: TranscriptBlock[],
-  queueMap: QueueRows,
-  signal: AbortSignal,
-) => {
-  const result: DxGridAxisMeta = { grid: {} };
-  for (let row = 0; row < queueMap.length; row++) {
-    await yieldOrContinue('smooth', signal);
-    const [blockIndex, segmentIndex] = queueMap[row];
-    if (segmentIndex < 0) {
-      result.grid[row] = { size: lineHeight + cellSpacing };
-    } else {
-      host.textContent = blocks[blockIndex]!.segments[segmentIndex]!.text;
-      result.grid[row] = { size: host.offsetHeight };
-    }
-  }
-  return result;
-};
-
-export type TranscriptViewProps = ThemedClassName<{
-  blocks?: TranscriptBlock[];
-  attendableId?: string;
-  ignoreAttention?: boolean;
-}>;
-
-/**
- * @@deprecated
- */
-export const Transcript: FC<TranscriptViewProps> = ({ classNames, blocks, attendableId, ignoreAttention }) => {
-  const { t } = useTranslation(meta.id);
-  const [dxGrid, setDxGrid] = useState<DxGridElement | null>(null);
-  const [rows, setRows] = useState<DxGridAxisMeta | undefined>(undefined);
-  const [columns, setColumns] = useState<DxGridAxisMeta | undefined>(undefined);
-
-  const queueMap = useMemo(() => mapTranscriptQueue(blocks), [blocks]);
-
-  const { hasAttention } = useAttention(attendableId);
-  const [autoScroll, setAutoScroll] = useState(true);
-  const handleWheel = useCallback(
-    (event: WheelEvent) => {
-      setAutoScroll(false);
-      if (!ignoreAttention && !hasAttention) {
-        event.stopPropagation();
-      }
-    },
-    [hasAttention, ignoreAttention],
-  );
-
-  const abortControllerRef = useRef<AbortController>(null);
-
-  const handleResize = useCallback(
-    async ({ entry }: { entry: { target: HTMLDivElement } | null }) => {
-      if (entry?.target && Array.isArray(blocks) && blocks[0] && queueMap) {
-        abortControllerRef.current?.abort();
-        abortControllerRef.current = new AbortController();
-        setColumns({ grid: { 0: { size: timestampColumnWidth }, 1: { size: entry.target.offsetWidth } } });
-        return measureRows(entry.target, blocks, queueMap, abortControllerRef.current.signal)
-          .then(setRows)
-          .catch(() => {
-            // Aborted mid-measurement by new size.
-          });
-      }
-    },
-    [blocks, queueMap],
-  );
-
-  const { width, ref: measureRef } = useResizeDetector({
-    onResize: handleResize as OnResizeCallback,
-    refreshOptions: { leading: true },
-  });
-
-  useEffect(() => {
-    if (queueMap.length !== Object.keys(rows?.grid ?? {}).length) {
-      void handleResize({ entry: { target: measureRef.current } }).then(() => {
-        if (autoScroll) {
-          // TODO(thure): Implement a deterministic way to do this when `rows` has fully settled and grid has a new `maxPosBlock`.
-          setTimeout(() => dxGrid?.scrollToEndRow(), 50);
-        }
-      });
-    }
-  }, [blocks, queueMap, width, autoScroll]);
-
-  useEffect(() => {
-    if (dxGrid && Array.isArray(blocks) && blocks[0]) {
-      const transcriptStart = blocks[0]!.segments[0]!.started;
-      dxGrid.getCells = (range, plane) => {
-        switch (plane) {
-          case 'grid': {
-            const cells: DxGridPlaneCells = {};
-            for (let row = range.start.row; row <= range.end.row && row < queueMap.length; row++) {
-              const [blockIndex, segmentIndex] = queueMap[row];
-
-              cells[toPlaneCellIndex({ col: 0, row })] = {
-                readonly: true,
-                value:
-                  segmentIndex < 0
-                    ? formatTimestamp(
-                        new Date(transcriptStart),
-                        new Date(blocks[blockIndex]!.segments[Math.max(0, segmentIndex)]!.started),
-                      )
-                    : '',
-                className: timestampClasses,
-              } satisfies DxGridCellValue;
-
-              cells[toPlaneCellIndex({ col: 1, row })] = (
-                segmentIndex < 0
-                  ? {
-                      readonly: true,
-                      accessoryHtml: `<span data-hue="${blocks[blockIndex]!.authorHue}" class="dx-text-hue">${blocks[blockIndex]!.authorName}</span>`,
-                      className: authorClasses,
-                    }
-                  : {
-                      readonly: true,
-                      value: blocks[blockIndex]!.segments[segmentIndex]!.text,
-                      className: segmentTextClasses,
-                    }
-              ) satisfies DxGridCellValue;
-            }
-            return cells;
-          }
-          default:
-            return {};
-        }
-      };
-    }
-  }, [dxGrid, blocks]);
-
-  const handleScrollToEnd = useCallback(() => {
-    setAutoScroll(true);
-    dxGrid?.scrollToEndRow();
-  }, [dxGrid, autoScroll]);
-
-  return (
-    <div role='none' className={mx('relative min-bs-0', classNames)}>
-      <Grid.Root id={`${attendableId}--transcript`}>
-        <Grid.Content
-          limitColumns={2}
-          limitRows={queueMap.length}
-          columns={columns}
-          rows={rows}
-          rowDefault={rowDefault}
-          onWheel={handleWheel}
-          className='[--dx-grid-base:var(--dx-baseSurface)] [--dx-grid-lines:var(--dx-baseSurface)] [&_.dx-grid]:min-bs-0 [&_.dx-grid]:min-is-0 [&_.dx-grid]:select-auto'
-          ref={setDxGrid}
-        />
-      </Grid.Root>
-      <div role='none' {...{ inert: true }} aria-hidden className={measureClasses} ref={measureRef} />
-      <IconButton
-        icon='ph--arrow-line-down--regular'
-        iconOnly
-        label={t('scroll to end label')}
-        tooltipSide='left'
-        data-state={autoScroll ? 'invisible' : 'visible'}
-        classNames={[
-          'absolute inline-end-2 block-end-2 opacity-0 pointer-events-none',
-          'data-[state="visible"]:pointer-events-auto data-[state="visible"]:opacity-100 transition-opacity',
-        ]}
-        onClick={handleScrollToEnd}
-      />
-    </div>
-  );
-};

package/src/components/TranscriptContainer.tsx

@@ -1,36 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React from 'react';
-
-import { fullyQualifiedId, getSpace } from '@dxos/client/echo';
-import { useMembers, useQueue } from '@dxos/react-client/echo';
-import { StackItem } from '@dxos/react-ui-stack';
-import { type DataType } from '@dxos/schema';
-
-import { useQueueModelAdapter } from '../hooks';
-import { type Transcript } from '../types';
-
-import { TranscriptView, renderByline } from './Transcript';
-
-export type TranscriptionContainerProps = {
-  role: string;
-  transcript: Transcript.Transcript;
-};
-
-export const TranscriptionContainer = ({ transcript }: TranscriptionContainerProps) => {
-  const attendableId = fullyQualifiedId(transcript);
-  const space = getSpace(transcript);
-  const members = useMembers(space?.key).map((member) => member.identity);
-  const queue = useQueue<DataType.Message>(transcript.queue.dxn, { pollInterval: 1_000 });
-  const model = useQueueModelAdapter(renderByline(members), queue);
-
-  return (
-    <StackItem.Content>
-      <TranscriptView attendableId={attendableId} space={space} model={model} transcript={transcript} />
-    </StackItem.Content>
-  );
-};
-
-export default TranscriptionContainer;

package/src/functions/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export { default as open } from './open';
-export { default as summarize } from './summarize';

package/src/functions/open.ts

@@ -1,39 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { ArtifactId } from '@dxos/assistant';
-import { Obj } from '@dxos/echo';
-import { DatabaseService, QueueService, defineFunction } from '@dxos/functions';
-import { DataType } from '@dxos/schema';
-
-import { renderByline } from '../components';
-import { Transcript } from '../types';
-
-export default defineFunction({
-  key: 'dxos.org/function/transcription/open',
-  name: 'Open',
-  description: 'Opens and reads the contents of a transcription object.',
-  inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
-      description: 'The ID of the transcription object.',
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    content: Schema.String,
-  }),
-  handler: Effect.fn(function* ({ data: { id } }) {
-    const transcript = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Transcript.Transcript);
-    const { dxn } = yield* Effect.promise(() => transcript.queue.load());
-    const queue = yield* QueueService.getQueue(dxn);
-    yield* Effect.promise(() => queue?.queryObjects());
-    const content = queue?.objects
-      .filter((message) => Obj.instanceOf(DataType.Message, message))
-      .flatMap((message, index) => renderByline([])(message, index))
-      .join('\n\n');
-    return { content };
-  }),
-});

package/src/types/Transcript.ts

@@ -1,44 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { Queue } from '@dxos/client/echo';
-import { type DXN, Obj, Ref, Type } from '@dxos/echo';
-
-/**
- * Root transcript object created when the user starts a transcription.
- */
-export const Transcript = Schema.Struct({
-  // TODO(wittjosiah): Remove?
-  // TODO(burdon): Use Date or string?
-  started: Schema.optional(Schema.String),
-  ended: Schema.optional(Schema.String),
-
-  /**
-   * Queue containing TranscriptBlock objects.
-   */
-  queue: Type.Ref(Queue),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Transcript',
-    version: '0.1.0',
-  }),
-);
-
-export type Transcript = Schema.Schema.Type<typeof Transcript>;
-
-// TODO(burdon): Do these need to be kept in sync with EDGE?
-
-/**
- * First message in queue.
- * Contains metadata for the recording and transcript.
- */
-const TranscriptHeader = Schema.Struct({
-  started: Schema.optional(Schema.String),
-});
-
-export type TranscriptHeader = Schema.Schema.Type<typeof TranscriptHeader>;
-
-export const makeTranscript = (queueDxn: DXN) => Obj.make(Transcript, { queue: Ref.fromDXN(queueDxn) });

package/src/types/TranscriptAction.ts

@@ -1,24 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { SpaceSchema } from '@dxos/client/echo';
-
-import { meta } from '../meta';
-
-import { Transcript } from './Transcript';
-
-/**
- * Endpoint to the calls service.
- */
-export class Create extends Schema.TaggedClass<Create>()(`${meta.id}/action/create`, {
-  input: Schema.Struct({
-    name: Schema.optional(Schema.String),
-    space: SpaceSchema,
-  }),
-  output: Schema.Struct({
-    object: Transcript,
-  }),
-}) {}