@4players/odin-common 4.0.0 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4players/odin-common",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "A collection of commonly used type definitions and utility functions across ODIN web projects",
   "author": "Josho Bleicker <josho.bleicker@4players.io> (https://www.4players.io)",
   "homepage": "https://www.4players.io",

package/plugin/api.d.ts

@@ -0,0 +1,159 @@
+export declare const MinDBFS = -758.596;
+export declare namespace Backend {
+    type UID = string;
+    type OnStatusChanged = (status: "started" | "stopped") => void;
+    type OnEvent = (method: string, properties: unknown) => void;
+    type Version = "5";
+    enum Transport {
+        H3 = "h3",
+        WebRTC = "webrtc"
+    }
+    interface Plugin {
+        readonly version: Version;
+        readonly playbackVolume: PlaybackVolume;
+        readonly supportedTransports: (Transport.WebRTC | Transport.H3)[];
+        joinRoom(parameters: JoinRoomParameters): Room;
+        createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
+        createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
+        createVideoCapture(ms: MediaStream, options?: VideoInputOptions): Promise<VideoCapture>;
+        createVideoPlayback(parameters: CreateVideoPlaybackParameters): Promise<VideoPlayback>;
+        enumerateDevices(): Promise<Array<Device>>;
+        setOutputVolume(volume: PlaybackVolume): void;
+        setOutputDevice(device: DeviceParameters): Promise<void>;
+        close(): void;
+    }
+    interface Device {
+        readonly type: "AudioPlayback" | "AudioCapture";
+        readonly name: string;
+        readonly id: string;
+        readonly isDefault: boolean;
+    }
+    interface DeviceParameters {
+        readonly device?: Device;
+        onStatusChanged?: OnStatusChanged;
+    }
+    interface Activity {
+        isSilent: boolean;
+        rmsDBFS: number;
+    }
+    interface JitterStats {
+        packetsSeen: number;
+        packetsProcessed: number;
+        packetsTooEarly: number;
+        packetsTooLate: number;
+        packetsDropped: number;
+        packetsInvalid: number;
+        packetsRepeated: number;
+        packetsLost: number;
+    }
+    interface ConnectionStats {
+        bytesSent: number;
+        bytesReceived: number;
+        packetsSent: number;
+        packetsReceived: number;
+        rtt: number;
+    }
+    interface JoinRoomParameters {
+        readonly gateway: string | undefined;
+        readonly token: string;
+        readonly roomId?: string;
+        readonly userData?: Uint8Array;
+        readonly position?: [number, number, number];
+        readonly cipher?: SetupCipherSettings;
+        readonly onEvent: OnEvent;
+        readonly transport?: Transport;
+    }
+    interface Room {
+        readonly token: string;
+        readonly cipher: Cipher | undefined;
+        connectionStats: ConnectionStats;
+        request(method: string, properties: unknown): Promise<unknown>;
+        link(media: Media): Promise<void>;
+        unlink(media: Media): void;
+        close(): void;
+    }
+    interface Media {
+        readonly customType?: string;
+        close(): void;
+    }
+    interface AudioMedia extends Media {
+        readonly activity: Activity;
+    }
+    interface CreateAudioPlaybackParameters {
+        readonly uid: UID;
+        readonly volume?: PlaybackVolume;
+        readonly customType?: string;
+    }
+    interface CreateVideoPlaybackParameters {
+        readonly uid: UID;
+        readonly customType?: string;
+    }
+    interface AudioPlayback extends AudioMedia {
+        readonly volume: PlaybackVolume;
+        readonly uid: UID;
+        jitterStats: JitterStats;
+        setVolume(value: PlaybackVolume): Promise<void>;
+    }
+    interface CreateAudioCaptureParameters extends Partial<DeviceParameters> {
+        readonly volume?: CaptureVolume;
+        readonly vad?: VadConfig;
+        readonly apm?: ApmConfig;
+    }
+    interface AudioCapture extends AudioMedia {
+        readonly volume: CaptureVolume;
+        readonly vad?: VadConfig;
+        readonly apm?: ApmConfig;
+        setVad(config: VadConfig): void;
+        setApm(config: ApmConfig): Promise<void>;
+        setDevice(device: DeviceParameters): Promise<void>;
+        setVolume(value: CaptureVolume): Promise<void>;
+    }
+    interface VideoCapture extends Media {
+        mediaStream?: MediaStream;
+        setDevice(ms: MediaStream): Promise<void>;
+    }
+    interface VideoPlayback extends Media {
+        readonly mediaStream?: MediaStream;
+        readonly uid: UID;
+    }
+    type PlaybackVolume = [number, number];
+    type CaptureVolume = "muted" | number;
+    interface VadConfig {
+        voiceActivity?: SensitivityRange;
+        volumeGate?: SensitivityRange;
+    }
+    interface SensitivityRange {
+        attackThreshold: number;
+        releaseThreshold: number;
+    }
+    interface ApmConfig {
+        echoCanceller: boolean;
+        highPassFilter: boolean;
+        preAmplifier: boolean;
+        captureLevelAdjustment: boolean;
+        noiseSuppression: "None" | "Low" | "Moderate" | "High" | "VeryHigh";
+        transientSuppressor: boolean;
+        gainController: boolean;
+    }
+    type SetupCipherSettings = {
+        type: "OdinCrypto";
+    } & OdinCryptoSettings;
+    type CipherSettings = OdinCryptoSettings;
+    interface OdinCryptoSettings {
+        password: string | null;
+    }
+    enum PeerCipherStatus {
+        InvalidPassword = -1,
+        Unknown = 0,
+        Unencrypted = 1,
+        Encrypted = 2
+    }
+    interface Cipher {
+        configure(settings: CipherSettings): void;
+        getPeerStatus(peerId: number): PeerCipherStatus;
+    }
+    type VideoInputOptions = {
+        codec?: "H264" | "VP8" | "VP9";
+        customType?: string;
+    };
+}

package/rpc/commands.d.ts

@@ -0,0 +1,253 @@
+import { type infer, z } from "zod";
+export type { infer as Infer };
+export type Commands = Record<string, {
+    request: z.ZodTypeAny;
+    response: z.ZodTypeAny;
+}>;
+export declare const MainCommandsRpc: {
+    Hello: {
+        request: z.ZodObject<{
+            stream: z.ZodLiteral<"main">;
+        }, "strip", z.ZodTypeAny, {
+            stream?: "main";
+        }, {
+            stream?: "main";
+        }>;
+        response: z.ZodNull;
+    };
+    JoinRoom: {
+        request: z.ZodObject<{
+            token: z.ZodString;
+            room_id: z.ZodString;
+            user_data: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+            position: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+        }, "strip", z.ZodTypeAny, {
+            position?: [number, number, number, ...unknown[]] | [number, number, ...unknown[]];
+            user_data?: Uint8Array;
+            room_id?: string;
+            token?: string;
+        }, {
+            position?: [number, number, number, ...unknown[]] | [number, number, ...unknown[]];
+            user_data?: Uint8Array;
+            room_id?: string;
+            token?: string;
+        }>;
+        response: z.ZodObject<{
+            peer_id: z.ZodNumber;
+            stream_id: z.ZodOptional<z.ZodNumber>;
+            token: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            peer_id?: number;
+            token?: string;
+            stream_id?: number;
+        }, {
+            peer_id?: number;
+            token?: string;
+            stream_id?: number;
+        }>;
+    };
+    WebRtcUpdate: {
+        request: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"Sdp">;
+            type: z.ZodEnum<["Answer", "Offer"]>;
+            sdp: z.ZodString;
+            media_map: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodString], null>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type?: "Answer" | "Offer";
+            kind?: "Sdp";
+            sdp?: string;
+            media_map?: [number, string, ...unknown[]][];
+        }, {
+            type?: "Answer" | "Offer";
+            kind?: "Sdp";
+            sdp?: string;
+            media_map?: [number, string, ...unknown[]][];
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"Trickle">;
+            candidate: z.ZodString;
+            spd_mid: z.ZodOptional<z.ZodString>;
+            spd_mline_index: z.ZodOptional<z.ZodNumber>;
+            username_fragment: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+        }, "strip", z.ZodTypeAny, {
+            candidate?: string;
+            kind?: "Trickle";
+            spd_mid?: string;
+            spd_mline_index?: number;
+            username_fragment?: string;
+        }, {
+            candidate?: string;
+            kind?: "Trickle";
+            spd_mid?: string;
+            spd_mline_index?: number;
+            username_fragment?: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"TrickleFinished">;
+        }, "strip", z.ZodTypeAny, {
+            kind?: "TrickleFinished";
+        }, {
+            kind?: "TrickleFinished";
+        }>]>;
+        response: z.ZodNull;
+    };
+    RequestReconnectToken: {
+        request: z.ZodObject<{
+            peer_id: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            peer_id?: number;
+        }, {
+            peer_id?: number;
+        }>;
+        response: z.ZodString;
+    };
+    Ping: {
+        request: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        response: z.ZodNull;
+    };
+};
+export type MainCommands = typeof MainCommandsRpc;
+export declare const RoomCommandsRpc: {
+    Hello: {
+        request: z.ZodObject<{
+            stream: z.ZodLiteral<"room">;
+            token: z.ZodString;
+            room_id: z.ZodString;
+            user_data: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+            position: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+        }, "strip", z.ZodTypeAny, {
+            stream?: "room";
+            position?: [number, number, number, ...unknown[]] | [number, number, ...unknown[]];
+            user_data?: Uint8Array;
+            room_id?: string;
+            token?: string;
+        }, {
+            stream?: "room";
+            position?: [number, number, number, ...unknown[]] | [number, number, ...unknown[]];
+            user_data?: Uint8Array;
+            room_id?: string;
+            token?: string;
+        }>;
+        response: z.ZodNull;
+    };
+    UpdatePeer: {
+        request: z.ZodObject<{
+            user_data: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+        }, "strip", z.ZodTypeAny, {
+            user_data?: Uint8Array;
+        }, {
+            user_data?: Uint8Array;
+        }>;
+        response: z.ZodNull;
+    };
+    StartMedia: {
+        request: z.ZodObject<{
+            media_id: z.ZodNumber;
+            properties: z.ZodUnion<[z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"audio">>;
+                uid: z.ZodOptional<z.ZodString>;
+                customType: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                uid?: string;
+                kind?: "audio";
+                customType?: string;
+            }, {
+                uid?: string;
+                kind?: "audio";
+                customType?: string;
+            }>, z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"video">>;
+                codec: z.ZodOptional<z.ZodString>;
+                uid: z.ZodOptional<z.ZodString>;
+                customType: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                codec?: string;
+                uid?: string;
+                kind?: "video";
+                customType?: string;
+            }, {
+                codec?: string;
+                uid?: string;
+                kind?: "video";
+                customType?: string;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            properties?: {
+                uid?: string;
+                kind?: "audio";
+                customType?: string;
+            } | {
+                codec?: string;
+                uid?: string;
+                kind?: "video";
+                customType?: string;
+            };
+            media_id?: number;
+        }, {
+            properties?: {
+                uid?: string;
+                kind?: "audio";
+                customType?: string;
+            } | {
+                codec?: string;
+                uid?: string;
+                kind?: "video";
+                customType?: string;
+            };
+            media_id?: number;
+        }>;
+        response: z.ZodNull;
+    };
+    StopMedia: {
+        request: z.ZodObject<{
+            media_id: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            media_id?: number;
+        }, {
+            media_id?: number;
+        }>;
+        response: z.ZodNull;
+    };
+    PauseMedia: {
+        request: z.ZodObject<{
+            media_id: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            media_id?: number;
+        }, {
+            media_id?: number;
+        }>;
+        response: z.ZodNull;
+    };
+    ResumeMedia: {
+        request: z.ZodObject<{
+            media_id: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            media_id?: number;
+        }, {
+            media_id?: number;
+        }>;
+        response: z.ZodNull;
+    };
+    SetPeerPosition: {
+        request: z.ZodObject<{
+            position: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+        }, "strip", z.ZodTypeAny, {
+            position?: [number, number, number, ...unknown[]] | [number, number, ...unknown[]];
+        }, {
+            position?: [number, number, number, ...unknown[]] | [number, number, ...unknown[]];
+        }>;
+        response: z.ZodNull;
+    };
+    SendMessage: {
+        request: z.ZodObject<{
+            target_peer_ids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+            message: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+        }, "strip", z.ZodTypeAny, {
+            message?: Uint8Array;
+            target_peer_ids?: number[];
+        }, {
+            message?: Uint8Array;
+            target_peer_ids?: number[];
+        }>;
+        response: z.ZodNull;
+    };
+};
+export type RoomCommands = typeof RoomCommandsRpc;