@livekit/rtc-node 0.13.2 → 0.13.4

package/src/data_streams/stream_reader.ts

@@ -0,0 +1,166 @@
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import type { ReadableStream } from 'node:stream/web';
+import { log } from '../log.js';
+import type { DataStream_Chunk } from '../proto/room_pb.js';
+import { bigIntToNumber } from '../utils.js';
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamChunk, TextStreamInfo } from './types.js';
+
+abstract class BaseStreamReader<T extends BaseStreamInfo> {
+  protected reader: ReadableStream<DataStream_Chunk>;
+
+  protected totalByteSize?: number;
+
+  protected _info: T;
+
+  protected bytesReceived: number;
+
+  get info() {
+    return this._info;
+  }
+
+  constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number) {
+    this.reader = stream;
+    this.totalByteSize = totalByteSize;
+    this._info = info;
+    this.bytesReceived = 0;
+  }
+
+  protected abstract handleChunkReceived(chunk: DataStream_Chunk): void;
+
+  onProgress?: (progress: number | undefined) => void;
+
+  abstract readAll(): Promise<string | Array<Uint8Array>>;
+}
+
+/**
+ * A class to read chunks from a ReadableStream and provide them in a structured format.
+ */
+export class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {
+  protected handleChunkReceived(chunk: DataStream_Chunk) {
+    this.bytesReceived += chunk.content!.byteLength;
+    const currentProgress = this.totalByteSize
+      ? this.bytesReceived / this.totalByteSize
+      : undefined;
+    this.onProgress?.(currentProgress);
+  }
+
+  [Symbol.asyncIterator]() {
+    const reader = this.reader.getReader();
+
+    return {
+      next: async (): Promise<IteratorResult<Uint8Array>> => {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            return { done: true, value: undefined as any };
+          } else {
+            this.handleChunkReceived(value);
+            return { done: false, value: value.content! };
+          }
+        } catch (error) {
+          log.error('error processing stream update', error);
+          return { done: true, value: undefined };
+        }
+      },
+
+      return(): IteratorResult<Uint8Array> {
+        reader.releaseLock();
+        return { done: true, value: undefined };
+      },
+    };
+  }
+
+  async readAll(): Promise<Array<Uint8Array>> {
+    const chunks: Set<Uint8Array> = new Set();
+    for await (const chunk of this) {
+      chunks.add(chunk);
+    }
+    return Array.from(chunks);
+  }
+}
+
+/**
+ * A class to read chunks from a ReadableStream and provide them in a structured format.
+ */
+export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
+  private receivedChunks: Map<number, DataStream_Chunk>;
+
+  /**
+   * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string
+   * that has been received up to the current point in time.
+   */
+  constructor(
+    info: TextStreamInfo,
+    stream: ReadableStream<DataStream_Chunk>,
+    totalChunkCount?: number,
+  ) {
+    super(info, stream, totalChunkCount);
+    this.receivedChunks = new Map();
+  }
+
+  protected handleChunkReceived(chunk: DataStream_Chunk) {
+    const index = bigIntToNumber(chunk.chunkIndex!);
+    const previousChunkAtIndex = this.receivedChunks.get(index!);
+    if (previousChunkAtIndex && previousChunkAtIndex.version! > chunk.version!) {
+      // we have a newer version already, dropping the old one
+      return;
+    }
+    this.receivedChunks.set(index, chunk);
+    const currentProgress = this.totalByteSize
+      ? this.receivedChunks.size / this.totalByteSize
+      : undefined;
+    this.onProgress?.(currentProgress);
+  }
+
+  /**
+   * Async iterator implementation to allow usage of `for await...of` syntax.
+   * Yields structured chunks from the stream.
+   *
+   */
+  [Symbol.asyncIterator]() {
+    const reader = this.reader.getReader();
+    const decoder = new TextDecoder();
+
+    return {
+      next: async (): Promise<IteratorResult<TextStreamChunk>> => {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            return { done: true, value: undefined };
+          } else {
+            this.handleChunkReceived(value);
+            return {
+              done: false,
+              value: {
+                index: bigIntToNumber(value.chunkIndex)!,
+                current: decoder.decode(value.content!),
+                collected: Array.from(this.receivedChunks.values())
+                  .sort((a, b) => bigIntToNumber(a.chunkIndex!) - bigIntToNumber(b.chunkIndex!))
+                  .map((chunk) => decoder.decode(chunk.content!))
+                  .join(''),
+              },
+            };
+          }
+        } catch (error) {
+          log.error('error processing stream update', error);
+          return { done: true, value: undefined };
+        }
+      },
+
+      return(): IteratorResult<TextStreamChunk> {
+        reader.releaseLock();
+        return { done: true, value: undefined };
+      },
+    };
+  }
+
+  async readAll(): Promise<string> {
+    let latestString: string = '';
+    for await (const { collected } of this) {
+      latestString = collected;
+    }
+    return latestString;
+  }
+}

package/src/data_streams/stream_writer.ts

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import type { WritableStream } from 'node:stream/web';
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types.js';
+
+class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
+  protected writableStream: WritableStream<[T, number?]>;
+
+  protected defaultWriter: WritableStreamDefaultWriter<[T, number?]>;
+
+  protected onClose?: () => void;
+
+  readonly info: InfoType;
+
+  constructor(writableStream: WritableStream<[T, number?]>, info: InfoType, onClose?: () => void) {
+    this.writableStream = writableStream;
+    this.defaultWriter = writableStream.getWriter();
+    this.onClose = onClose;
+    this.info = info;
+  }
+
+  write(chunk: T, chunkIndex?: number): Promise<void> {
+    return this.defaultWriter.write([chunk, chunkIndex]);
+  }
+
+  async close() {
+    await this.defaultWriter.close();
+    this.defaultWriter.releaseLock();
+    this.onClose?.();
+  }
+}
+
+export class TextStreamWriter extends BaseStreamWriter<string, TextStreamInfo> {}
+
+export class ByteStreamWriter extends BaseStreamWriter<Uint8Array, ByteStreamInfo> {}

package/src/data_streams/types.ts

@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import type { DataStream_Chunk, DataStream_Header } from '../proto/room_pb.js';
+import type { ByteStreamReader, TextStreamReader } from './stream_reader.js';
+
+export interface StreamController<T extends DataStream_Chunk> {
+  header: DataStream_Header;
+  controller: ReadableStreamDefaultController<T>;
+  startTime: number;
+  endTime?: number;
+}
+
+export interface BaseStreamInfo {
+  streamId: string;
+  mimeType: string;
+  topic: string;
+  timestamp: number;
+  /** total size in bytes for finite streams and undefined for streams of unknown size */
+  totalSize?: number;
+  attributes?: Record<string, string>;
+}
+
+export type ByteStreamInfo = BaseStreamInfo & {
+  name: string;
+};
+
+export type TextStreamInfo = BaseStreamInfo;
+
+export type TextStreamChunk = {
+  index: number;
+  current: string;
+  collected: string;
+};
+
+export interface DataStreamOptions {
+  topic?: string;
+  destinationIdentities?: Array<string>;
+  attributes?: Record<string, string>;
+  mimeType?: string;
+}
+
+export interface TextStreamOptions extends DataStreamOptions {
+  // replyToMessageId?: string;
+  attachments?: [];
+}
+
+export interface ByteStreamOptions extends DataStreamOptions {
+  name?: string;
+  onProgress?: (progress: number) => void;
+}
+
+export type ByteStreamHandler = (
+  reader: ByteStreamReader,
+  participantInfo: { identity: string },
+) => void;
+
+export type TextStreamHandler = (
+  reader: TextStreamReader,
+  participantInfo: { identity: string },
+) => void;

package/src/index.ts

@@ -30,6 +30,7 @@ export {
 export type { Transcription, TranscriptionSegment } from './transcription.js';
 export { E2EEManager, KeyProvider, FrameCryptor } from './e2ee.js';
 export type { E2EEOptions, KeyProviderOptions } from './e2ee.js';
+export * from './data_streams/index.js';
 export {
   ConnectionQuality,
   IceServer,

package/src/log.ts

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import type { LevelWithSilent, LoggerOptions } from 'pino';
+import { pino } from 'pino';
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+const defaultOptions: LoggerOptions = { name: 'lk-rtc' };
+
+const devOptions: LoggerOptions = {
+  ...defaultOptions,
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+    },
+  },
+};
+
+const log = pino(isProduction ? defaultOptions : devOptions);
+log.level = isProduction ? 'info' : 'debug';
+
+export type LogLevel = LevelWithSilent;
+export { log };

package/src/napi/native.d.ts

@@ -3,15 +3,15 @@
 
 /* auto-generated by NAPI-RS */
 
-export function livekitInitialize(
+export declare function livekitInitialize(
   callback: (data: Uint8Array) => void,
   captureLogs: boolean,
   sdkVersion: string,
 ): void;
-export function livekitFfiRequest(data: Uint8Array): Uint8Array;
-export function livekitRetrievePtr(handle: Uint8Array): bigint;
-export function livekitCopyBuffer(ptr: bigint, len: number): Uint8Array;
-export function livekitDispose(): Promise<void>;
+export declare function livekitFfiRequest(data: Uint8Array): Uint8Array;
+export declare function livekitRetrievePtr(handle: Uint8Array): bigint;
+export declare function livekitCopyBuffer(ptr: bigint, len: number): Uint8Array;
+export declare function livekitDispose(): Promise<void>;
 export declare class FfiHandle {
   constructor(handle: bigint);
   dispose(): void;