@dxos/plugin-transcription 0.7.5-main.b19bfc8

package/src/translations.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { TRANSCRIPTION_PLUGIN } from './meta';
+import { TranscriptType } from './types';
+
+export default [
+  {
+    'en-US': {
+      [TranscriptType.typename]: {
+        'typename label': 'Transcript',
+      },
+      [TRANSCRIPTION_PLUGIN]: {
+        'plugin name': 'Transcription',
+        'calls label': 'Transcript',
+        'calls panel label': 'Transcription',
+        'create calls label': 'Create transcription',
+        'delete calls label': 'Delete',
+
+        'delete button': 'Delete',
+        'bookmark button': 'Bookmark',
+        'summary button': 'Create summary',
+        'summarizing label': 'Summarizing...',
+      },
+    },
+  },
+];

package/src/types/index.ts

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

package/src/types/schema.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EchoObject, ObjectId, S, TypedObject } from '@dxos/echo-schema';
+
+/**
+ * Root transcript object created when the user starts a transcription.
+ */
+export const TranscriptSchema = S.Struct({
+  name: S.String,
+
+  // TODO(burdon): Use string for dates?
+  started: S.optional(S.Date),
+  ended: S.optional(S.Date),
+
+  /**
+   * Queue containing TranscriptBlock objects.
+   */
+  queue: S.optional(S.String),
+});
+
+export class TranscriptType extends TypedObject({
+  typename: 'dxos.org/type/Transcript',
+  version: '0.1.0',
+})(TranscriptSchema.fields) {}
+
+// 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 = S.Struct({
+  started: S.optional(S.Date),
+});
+
+export type TranscriptHeader = S.Schema.Type<typeof TranscriptHeader>;
+
+/**
+ * Transcription fragment.
+ */
+const TranscriptSegment = S.Struct({
+  // TODO(burdon): TS from service is not Unix TS (x1000).
+  started: S.Date,
+  text: S.String,
+});
+
+export type TranscriptSegment = S.Schema.Type<typeof TranscriptSegment>;
+
+/**
+ * Transcription block (from single speaker).
+ */
+export const TranscriptBlock = S.Struct({
+  id: ObjectId,
+  author: S.optional(S.String), // TODO(burdon): DID?
+  segments: S.Array(TranscriptSegment),
+}).pipe(EchoObject('dxos.org/type/TranscriptBlock', '0.1.0'));
+
+export type TranscriptBlock = S.Schema.Type<typeof TranscriptBlock>;

package/src/types/types.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { S, isInstanceOf } from '@dxos/echo-schema';
+import { isReactiveObject } from '@dxos/react-client/echo';
+
+import { TranscriptSchema, TranscriptType } from './schema';
+import { TRANSCRIPTION_PLUGIN } from '../meta';
+
+// TODO(burdon): Move to separate proto.
+
+/**
+ * Endpoint to the calls service.
+ */
+// TODO(burdon): Reconfigure/move.
+export const TRANSCRIPTION_URL = 'https://calls-service.dxos.workers.dev';
+
+export namespace TranscriptionAction {
+  const TRANSCRIPTION_ACTION = `${TRANSCRIPTION_PLUGIN}/action`;
+
+  export class Create extends S.TaggedClass<Create>()(`${TRANSCRIPTION_ACTION}/create`, {
+    input: S.Struct({
+      name: S.optional(S.String),
+    }),
+    output: S.Struct({
+      object: TranscriptSchema,
+    }),
+  }) {}
+}
+
+export const isTranscript = (object: unknown): object is typeof TranscriptType => {
+  return isReactiveObject(object) && isInstanceOf(TranscriptType, object);
+};

package/src/util/array.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const mergeFloat64Arrays = (arrays: Float64Array[]) => {
+  const newArray = new Float64Array(arrays.reduce((acc, array) => array.length + acc, 0));
+  let offset = 0;
+  for (const array of arrays) {
+    newArray.set(array, offset);
+    offset += array.length;
+  }
+
+  return newArray;
+};

package/src/util/get-time-str.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const getTimeStr = (timestamp?: number) =>
+  new Date(timestamp ?? Date.now()).toLocaleTimeString('en-US', {
+    timeZone: 'UTC',
+    hour12: true,
+    hour: 'numeric',
+    minute: '2-digit',
+    second: '2-digit',
+  });

package/src/util/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './array';
+export * from './get-time-str';
+export * from './monitor-audio-level';
+export * from './random-queue-dxn';

package/src/util/monitor-audio-level.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const monitorAudioLevel = ({
+  mediaStreamTrack,
+  onMeasure,
+  intervalMs = 1000 / 10, // 12 fps.
+}: {
+  mediaStreamTrack: MediaStreamTrack;
+  onMeasure: (value: number) => void;
+  intervalMs?: number;
+}) => {
+  let timeout = -1;
+  let interval = -1;
+  const audioContext = new AudioContext();
+  const stream = new MediaStream();
+  stream.addTrack(mediaStreamTrack);
+  const mediaStreamAudioSourceNode = audioContext.createMediaStreamSource(stream);
+  const analyserNode = audioContext.createAnalyser();
+  mediaStreamAudioSourceNode.connect(analyserNode);
+  // Since we just need a rough approximation and will be measuring
+  // frequently, we want to drop this down from the default of 2048.
+  analyserNode.fftSize = 32;
+
+  const pcmData = new Float32Array(analyserNode.fftSize);
+  let peak = 0;
+
+  interval = window.setInterval(() => {
+    onMeasure(peak);
+    peak = 0;
+  }, intervalMs);
+
+  const tick = () => {
+    timeout = window.setTimeout(() => {
+      analyserNode.getFloatTimeDomainData(pcmData);
+      let sumSquares = 0.0;
+      for (const amplitude of pcmData) {
+        sumSquares += amplitude * amplitude;
+      }
+      const current = Math.sqrt(sumSquares / pcmData.length);
+      if (current > peak) {
+        peak = current;
+      }
+      tick();
+    }, intervalMs);
+  };
+  tick();
+
+  return () => {
+    mediaStreamAudioSourceNode.disconnect();
+    analyserNode.disconnect();
+    void audioContext.close();
+    clearInterval(interval);
+    clearTimeout(timeout);
+    stream.removeTrack(mediaStreamTrack);
+  };
+};

package/src/util/random-queue-dxn.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ObjectId } from '@dxos/echo-schema';
+import { DXN, QueueSubspaceTags, SpaceId } from '@dxos/keys';
+
+export const randomQueueDxn = () =>
+  new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, SpaceId.random(), ObjectId.random()]);