@4players/odin-plugin-web 1.0.0-alpha.12 → 1.0.0-alpha.14

package/lib/plugin/audioController.d.ts

@@ -87,7 +87,8 @@ export declare class AudioCapture implements Backend.AudioCapture {
     private _Vad;
     private _Apm;
     private _Volume;
-    private _deviceParameters?;
+    private _DeviceParameters?;
+    private _DeviceCb;
     get vad(): Backend.VadConfig;
     get apm(): Backend.ApmConfig;
     get volume(): Backend.Volume;

package/lib/plugin/audioController.js

@@ -339,7 +339,7 @@ export class AudioCapture {
     }
     get deviceId() {
         var _a, _b;
-        return (_b = (_a = this._deviceParameters) === null || _a === void 0 ? void 0 : _a.device) === null || _b === void 0 ? void 0 : _b.device.deviceId;
+        return (_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.device) === null || _b === void 0 ? void 0 : _b.device.deviceId;
     }
     constructor(controller, parameters) {
         this.controller = controller;
@@ -347,6 +347,19 @@ export class AudioCapture {
         this._Vad = defaultVad;
         this._Apm = defaultApm;
         this._Volume = 1;
+        this._DeviceCb = () => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const devices = yield this.controller.enumerateDevices();
+            const isListed = devices.some((device) => {
+                var _a, _b;
+                return (device.device.deviceId ===
+                    ((_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.device) === null || _b === void 0 ? void 0 : _b.device.deviceId));
+            });
+            if (!isListed) {
+                (_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.onStatusChanged) === null || _b === void 0 ? void 0 : _b.call(_a, 'stopped');
+                navigator.mediaDevices.removeEventListener('devicechange', this._DeviceCb);
+            }
+        });
         if (parameters.apm) {
             this.setApm(parameters.apm);
         }
@@ -397,25 +410,28 @@ export class AudioCapture {
     setApm(config) {
         return __awaiter(this, void 0, void 0, function* () {
             this._Apm = config;
-            if (this._deviceParameters) {
-                yield this.setDevice(this._deviceParameters);
+            if (this._DeviceParameters) {
+                yield this.setDevice(this._DeviceParameters);
             }
         });
     }
     setDevice(parameters) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const rollbackParams = this._deviceParameters;
-            this._deviceParameters = parameters;
+            const rollbackParams = this._DeviceParameters;
+            this._DeviceParameters = parameters;
             if (this._Volume === 'muted') {
                 return;
             }
             const device = yield openCaptureDevice(this.controller, parameters, this._Apm);
             if (device.type !== 'Success') {
                 console.error(`unable to open capture device; ${device.reason}`);
-                this._deviceParameters = rollbackParams;
+                this._DeviceParameters = rollbackParams;
                 return;
             }
+            if (this._DeviceParameters.onStatusChanged) {
+                navigator.mediaDevices.addEventListener('devicechange', this._DeviceCb);
+            }
             if (this._Capture !== undefined) {
                 stopMediaStream(this._Capture.source.mediaStream);
                 this._Capture.source.disconnect(this._Capture.worker.worklet);
@@ -445,8 +461,8 @@ export class AudioCapture {
             this.close();
         }
         else {
-            if (!this._Capture && this._deviceParameters) {
-                this.setDevice(this._deviceParameters);
+            if (!this._Capture && this._DeviceParameters) {
+                this.setDevice(this._DeviceParameters);
             }
             (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.setVolume(value);
         }
@@ -458,6 +474,7 @@ export class AudioCapture {
             this._Capture.source.disconnect(this._Capture.worker.worklet);
             this.controller.audioContexts.release(this._Capture.source.context);
         }
+        navigator.mediaDevices.removeEventListener('devicechange', this._DeviceCb);
         this._Capture = undefined;
     }
     _UpdateMedias() {

package/lib/plugin/mainConnection.js

@@ -46,29 +46,31 @@ export class MainConnection {
         return this.connection.closed;
     }
     webRtcReady() {
-        const isReady = () => {
-            switch (this.webRtc.connectionState) {
-                case 'connected':
-                    return true;
-                case 'failed':
-                case 'closed':
-                    return false;
-                default:
-                    return undefined;
-            }
-        };
-        const result = isReady();
-        if (result !== undefined)
-            return Promise.resolve(result);
-        return new Promise((accept) => {
-            const onConnectionStateChanged = () => {
-                const result = isReady();
-                if (result !== undefined) {
-                    this.webRtc.removeEventListener('connectionstatechange', onConnectionStateChanged);
-                    accept(result);
+        return __awaiter(this, void 0, void 0, function* () {
+            const isReady = () => {
+                switch (this.webRtc.connectionState) {
+                    case 'connected':
+                        return true;
+                    case 'failed':
+                    case 'closed':
+                        return false;
+                    default:
+                        return undefined;
                 }
             };
-            this.webRtc.addEventListener('connectionstatechange', onConnectionStateChanged);
+            const result = isReady();
+            if (result !== undefined)
+                return result;
+            return new Promise((accept) => {
+                const onConnectionStateChanged = () => {
+                    const result = isReady();
+                    if (result !== undefined) {
+                        this.webRtc.removeEventListener('connectionstatechange', onConnectionStateChanged);
+                        accept(result);
+                    }
+                };
+                this.webRtc.addEventListener('connectionstatechange', onConnectionStateChanged);
+            });
         });
     }
     constructor(id, url, onDatagram, connection, webRtc) {

package/lib/plugin/roomConnection.d.ts

@@ -1,5 +1,4 @@
-import { Backend, RoomCommands, Result } from '@4players/odin-common';
-import { z } from 'zod';
+import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
 import { Token } from './token';
@@ -14,6 +13,8 @@ export declare class RoomConnection {
     private _Token;
     private _UserData;
     private _Position;
+    private _ConnectionFailures;
+    private _FailureLimit;
     private _LastTokenRenew;
     private readonly _Closed;
     get token(): Token;
@@ -23,7 +24,7 @@ export declare class RoomConnection {
     get mainConnection(): MainConnection | undefined;
     constructor(connectionPool: ConnectionPool, onEvent: Backend.OnEvent, gateway: URL | undefined, token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]);
     request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
-    typedRequest<Name extends Extract<keyof RoomCommands, string>>(name: Name, properties: z.infer<RoomCommands[Name]['request']>): Promise<Result<z.infer<RoomCommands[Name]['response']>> | 'closed'>;
+    typedRequest<Name extends Extract<keyof RoomCommands, string>>(name: Name, properties: Infer<RoomCommands[Name]['request']>): Promise<Result<Infer<RoomCommands[Name]['response']>> | 'closed'>;
     close(): void;
     get renewTokenIn(): number;
     private _Main;

package/lib/plugin/roomConnection.js

@@ -8,7 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Selector, failure, sleep, success, RoomCommandsRpc, } from '@4players/odin-common';
-import { z } from 'zod';
 import { RpcConnection } from './rpcConnection';
 import { Token } from './token';
 import { ConnectTimeout, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
@@ -34,6 +33,8 @@ export class RoomConnection {
         this.gateway = gateway;
         this.roomId = roomId;
         this._Close = new AbortController();
+        this._ConnectionFailures = 0;
+        this._FailureLimit = 5;
         this._LastTokenRenew = performance.now();
         this._Closed = new Promise((accept) => this._Close.signal.addEventListener('abort', () => accept('closed'), {
             once: true,
@@ -144,6 +145,10 @@ export class RoomConnection {
                 if (mainConnection === 'closed')
                     return failure('connection pool closed'); // connection pool is closed
                 if (mainConnection.type === 'Failure') {
+                    if (this._ConnectionFailures < this._FailureLimit) {
+                        this._ConnectionFailures++;
+                        return failure(`Connection failed; ${mainConnection.reason}`);
+                    }
                     this._ChangeStatus('Joining', `connection failed; ${mainConnection.reason}`);
                     return success('continue');
                 }
@@ -180,13 +185,11 @@ export class RoomConnection {
         });
     }
     _ChangeStatus(status, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const properties = {
-                status,
-                message,
-            };
-            this.onEvent('RoomStatusChanged', properties);
-        });
+        const properties = {
+            status,
+            message,
+        };
+        this.onEvent('RoomStatusChanged', properties);
     }
     _HandleConnection(main, webSocket) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -264,6 +267,7 @@ export class RoomConnection {
     }
 }
 function contactGateway(gateway, token, signal) {
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const response = yield fetch(gateway, {
@@ -275,24 +279,13 @@ function contactGateway(gateway, token, signal) {
                 },
                 signal,
             });
-            const schema = z.union([
-                z.object({
-                    result: z.object({
-                        token: z.string(),
-                    }),
-                }),
-                z.object({
-                    error: z.object({
-                        message: z.string(),
-                    }),
-                }),
-            ]);
-            const body = schema.parse(yield response.json());
+            // TODO: re-add validation once schemas are available in common
+            const body = yield response.json();
             if ('result' in body) {
                 return Token.parse(body.result.token);
             }
             else {
-                console.error(`gateway rejected token; ${body.error.message}`);
+                console.error(`gateway rejected token; ${(_b = (_a = body.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'malformed response'}`);
                 return success('rejected');
             }
         }

package/lib/plugin/rpcConnection.d.ts

@@ -1,5 +1,4 @@
-import * as z from 'zod';
-import { Result, Accept, MessagePackRpc, Notifications } from '@4players/odin-common';
+import { Result, Accept, MessagePackRpc, Notifications, Infer, Commands } from '@4players/odin-common';
 export interface RpcMessage {
     name: string;
     properties: unknown;
@@ -31,25 +30,20 @@ export declare class RpcConnection {
     private _OnEvent;
     private _Cleanup;
 }
-export type Commands = Record<string, {
-    request: z.ZodTypeAny;
-    response: z.ZodTypeAny;
-}>;
-export type Events = Record<string, z.ZodTypeAny>;
 export interface TypedRpcMessage<Name extends string, Properties> extends RpcMessage {
     name: Name;
     properties: Properties;
 }
-export type RealizedEvents<E extends Events> = {
-    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, z.infer<E[Name]>>;
+export type RealizedEvents<E extends Notifications> = {
+    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, Infer<E[Name]>>;
 }[Extract<keyof E, string>];
-export declare class TypedRpcConnection<C extends Commands, E extends Events> extends RpcConnection {
+export declare class TypedRpcConnection<C extends Commands, E extends Notifications> extends RpcConnection {
     readonly _Commands: C;
     readonly _Events: E;
     constructor(webSocket: WebSocket, _Commands: C, _Events: E);
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): Promise<Result<z.infer<C[Name]['response']>> | 'closed'>;
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>, timeout: number): Promise<Result<z.infer<C[Name]['response']>> | 'closed' | 'timeout'>;
-    notify<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): void;
+    request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): Promise<Result<Infer<C[Name]['response']>> | 'closed'>;
+    request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>, timeout: number): Promise<Result<Infer<C[Name]['response']>> | 'closed' | 'timeout'>;
+    notify<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): void;
     recv(): Promise<RealizedEvents<E> | 'closed'>;
 }
 export declare function parseRpc(buffer: ArrayBuffer): Result<MessagePackRpc>;

package/lib/plugin/token.d.ts

@@ -1,5 +1,4 @@
-import { z } from 'zod';
-import { TokenAudienceSchema, TokenClaims, Result } from '@4players/odin-common';
+import { TokenAudienceSchema, TokenClaims, Result, Infer } from '@4players/odin-common';
 export declare class Token {
     readonly text: string;
     readonly claims: TokenClaims;
@@ -11,6 +10,6 @@ export declare class Token {
     get address(): URL | undefined;
     get upstream(): Token | undefined;
     get defaultRoomId(): string | undefined;
-    hasAudience(audience: z.infer<typeof TokenAudienceSchema>): boolean;
+    hasAudience(audience: Infer<typeof TokenAudienceSchema>): boolean;
     toString(): string;
 }