livekit-client 2.13.3 → 2.13.5

package/src/room/attribute-typings.ts

@@ -0,0 +1,61 @@
+// This file was generated from JSON Schema using quicktype, do not modify it directly.
+// The code generation lives at https://github.com/livekit/attribute-definitions
+//
+// To parse this data:
+//
+//   import { Convert, AgentAttributes, TranscriptionAttributes } from "./file";
+//
+//   const agentAttributes = Convert.toAgentAttributes(json);
+//   const transcriptionAttributes = Convert.toTranscriptionAttributes(json);
+
+export interface AgentAttributes {
+  'lk.agent.inputs'?: AgentInput[];
+  'lk.agent.outputs'?: AgentOutput[];
+  'lk.agent.state'?: AgentState;
+  'lk.publish_on_behalf'?: string;
+  [property: string]: any;
+}
+
+export type AgentInput = 'audio' | 'video' | 'text';
+
+export type AgentOutput = 'transcription' | 'audio';
+
+export type AgentState = 'idle' | 'initializing' | 'listening' | 'thinking' | 'speaking';
+
+/**
+ * Schema for transcription-related attributes
+ */
+export interface TranscriptionAttributes {
+  /**
+   * The segment id of the transcription
+   */
+  'lk.segment_id'?: string;
+  /**
+   * The associated track id of the transcription
+   */
+  'lk.transcribed_track_id'?: string;
+  /**
+   * Whether the transcription is final
+   */
+  'lk.transcription_final'?: boolean;
+  [property: string]: any;
+}
+
+// Converts JSON strings to/from your types
+export class Convert {
+  public static toAgentAttributes(json: string): AgentAttributes {
+    return JSON.parse(json);
+  }
+
+  public static agentAttributesToJson(value: AgentAttributes): string {
+    return JSON.stringify(value);
+  }
+
+  public static toTranscriptionAttributes(json: string): TranscriptionAttributes {
+    return JSON.parse(json);
+  }
+
+  public static transcriptionAttributesToJson(value: TranscriptionAttributes): string {
+    return JSON.stringify(value);
+  }
+}

package/src/room/participant/LocalParticipant.ts

@@ -260,6 +260,8 @@ export default class LocalParticipant extends Participant {
       .on(EngineEvent.Disconnected, this.handleDisconnected)
       .on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket);
+
+    this.signalConnectedFuture = undefined;
   }
 
   private handleReconnecting = () => {

package/src/utils/cloneDeep.ts

@@ -4,6 +4,10 @@ export function cloneDeep<T>(value: T): T {
   }
 
   if (typeof structuredClone === 'function') {
+    if (typeof value === 'object' && value !== null) {
+      // ensure that the value is not a proxy by spreading it
+      return structuredClone({ ...value });
+    }
     return structuredClone(value);
   } else {
     return JSON.parse(JSON.stringify(value)) as T;

package/src/utils/dataPacketBuffer.ts

@@ -0,0 +1,52 @@
+export interface DataPacketItem {
+  data: Uint8Array;
+  sequence: number;
+}
+
+export class DataPacketBuffer {
+  private buffer: DataPacketItem[] = [];
+
+  private _totalSize = 0;
+
+  push(item: DataPacketItem) {
+    this.buffer.push(item);
+    this._totalSize += item.data.byteLength;
+  }
+
+  pop(): DataPacketItem | undefined {
+    const item = this.buffer.shift();
+    if (item) {
+      this._totalSize -= item.data.byteLength;
+    }
+    return item;
+  }
+
+  getAll(): DataPacketItem[] {
+    return this.buffer.slice();
+  }
+
+  popToSequence(sequence: number) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (first.sequence <= sequence) {
+        this.pop();
+      } else {
+        break;
+      }
+    }
+  }
+
+  alignBufferedAmount(bufferedAmount: number) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (this._totalSize - first.data.byteLength <= bufferedAmount) {
+        break;
+      }
+      this.pop();
+    }
+  }
+
+  get length(): number {
+    return this.buffer.length;
+  }
+}

package/src/utils/ttlmap.ts

@@ -0,0 +1,96 @@
+export class TTLMap<K, V> {
+  private _map = new Map<K, { value: V; expiresAt: number }>();
+
+  private ttl: number;
+
+  private _lastCleanup = 0;
+
+  /**
+   * @param ttl ttl of the key (ms)
+   */
+  constructor(ttl: number) {
+    this.ttl = ttl;
+  }
+
+  set(key: K, value: V) {
+    const now = Date.now();
+    if (now - this._lastCleanup > this.ttl / 2) {
+      this.cleanup();
+    }
+    const expiresAt = now + this.ttl;
+    this._map.set(key, { value, expiresAt });
+    return this;
+  }
+
+  get(key: K): V | undefined {
+    const entry = this._map.get(key);
+    if (!entry) return undefined;
+    if (entry.expiresAt < Date.now()) {
+      this._map.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  has(key: K): boolean {
+    const entry = this._map.get(key);
+    if (!entry) return false;
+    if (entry.expiresAt < Date.now()) {
+      this._map.delete(key);
+      return false;
+    }
+    return true;
+  }
+
+  delete(key: K): boolean {
+    return this._map.delete(key);
+  }
+
+  clear() {
+    this._map.clear();
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt < now) {
+        this._map.delete(key);
+      }
+    }
+    this._lastCleanup = now;
+  }
+
+  get size() {
+    this.cleanup();
+    return this._map.size;
+  }
+
+  forEach(callback: (value: V, key: K, map: Map<K, V>) => void) {
+    this.cleanup();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt >= Date.now()) {
+        callback(entry.value, key, this.asValueMap());
+      }
+    }
+  }
+
+  map<U>(callback: (value: V, key: K, map: Map<K, V>) => U): U[] {
+    this.cleanup();
+    const result: U[] = [];
+    const valueMap = this.asValueMap();
+    for (const [key, value] of valueMap.entries()) {
+      result.push(callback(value, key, valueMap));
+    }
+    return result;
+  }
+
+  private asValueMap(): Map<K, V> {
+    const result = new Map<K, V>();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt >= Date.now()) {
+        result.set(key, entry.value);
+      }
+    }
+    return result;
+  }
+}