Data tracks - outgoing manager

.changeset/thin-jobs-grab.md

@@ -0,0 +1,5 @@
+---
+'livekit-client': patch
+---
+
+Adds new OutgoingDataTrackManager to manage sending data track payloads

src/index.ts

@@ -15,7 +15,7 @@ import * as attributes from './room/attribute-typings';
 // FIXME: remove this import in a follow up data track pull request.
 import './room/data-track/depacketizer';
 // FIXME: remove this import in a follow up data track pull request.
-import './room/data-track/packetizer';
+import './room/data-track/outgoing/OutgoingDataTrackManager';
 import LocalParticipant from './room/participant/LocalParticipant';
 import Participant, { ConnectionQuality, ParticipantKind } from './room/participant/Participant';
 import type { ParticipantTrackPermission } from './room/participant/ParticipantTrackPermission';

src/room/data-track/depacketizer.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { DataTrackDepacketizer } from './depacketizer';
+import DataTrackDepacketizer from './depacketizer';
 import { DataTrackHandle } from './handle';
 import { DataTrackPacket, DataTrackPacketHeader, FrameMarker } from './packet';
 import { DataTrackTimestamp, WrapAroundUnsignedInt } from './utils';

src/room/data-track/depacketizer.ts

@@ -85,7 +85,7 @@ type PushOptions = {
   errorOnPartialFrames: boolean;
 };
 
-export class DataTrackDepacketizer {
+export default class DataTrackDepacketizer {
   /** Maximum number of packets to buffer per frame before dropping. */
   static MAX_BUFFER_PACKETS = 128;
 

src/room/data-track/e2ee.ts

@@ -0,0 +1,14 @@
+export type EncryptedPayload = {
+  payload: Uint8Array;
+  iv: Uint8Array; // NOTE: should be 12 bytes long
+  keyIndex: number;
+};
+
+export type EncryptionProvider = {
+  // FIXME: add in explicit `Throws<..., EncryptionError>`?
+  encrypt(payload: Uint8Array): EncryptedPayload;
+};
+
+export type DecryptionProvider = {
+  decrypt(payload: Uint8Array, senderIdentity: string): Uint8Array;
+};

src/room/data-track/frame.ts

@@ -1,5 +1,5 @@
 import { DataTrackExtensions } from './packet/extensions';
-import { DataTrackPacketizer } from './packetizer';
+import DataTrackPacketizer from './packetizer';
 
 /** A pair of payload bytes and packet extensions which can be fed into a {@link DataTrackPacketizer}. */
 export type DataTrackFrame = {

src/room/data-track/handle.test.ts

@@ -4,7 +4,7 @@ import { DataTrackHandle } from './handle';
 
 describe('DataTrackHandle', () => {
   it('should parse handle raw inputs', () => {
-    expect(DataTrackHandle.fromNumber(3).value).toEqual(3);
+    expect(DataTrackHandle.fromNumber(3)).toEqual(3);
     expect(() => DataTrackHandle.fromNumber(0)).toThrow('0x0 is a reserved value');
     expect(() => DataTrackHandle.fromNumber(9999999)).toThrow(
       'Value too large to be a valid track handle',

src/room/data-track/handle.ts

@@ -41,10 +41,9 @@ export class DataTrackHandleError<
   }
 }
 
-export class DataTrackHandle {
-  public value: number;
-
-  static fromNumber(
+export type DataTrackHandle = number;
+export const DataTrackHandle = {
+  fromNumber(
     raw: number,
   ): Throws<
     DataTrackHandle,
@@ -57,24 +56,20 @@ export class DataTrackHandle {
     if (raw > U16_MAX_SIZE) {
       throw DataTrackHandleError.tooLarge();
     }
-    return new DataTrackHandle(raw);
-  }
-
-  constructor(raw: number) {
-    this.value = raw;
-  }
-}
+    return raw;
+  },
+};
 
 /** Manage allocating new handles which don't conflict over the lifetime of the client. */
 export class DataTrackHandleAllocator {
-  static value = 0;
+  value = 0;
 
   /** Returns a unique track handle for the next publication, if one can be obtained. */
-  static get(): DataTrackHandle | null {
+  get(): DataTrackHandle | null {
     this.value += 1;
     if (this.value > U16_MAX_SIZE) {
       return null;
     }
-    return new DataTrackHandle(this.value);
+    return this.value;
   }
 }