@4players/odin-plugin-web 1.0.0-alpha.20 → 1.0.0-alpha.22

package/lib/plugin/connectionPool.d.ts

@@ -1,6 +1,6 @@
-import { Result } from '@4players/odin-common';
+import { Result, Backend } from '@4players/odin-common';
 import { DatagramHandler, MainConnection } from './mainConnection';
-import { Transport } from './index';
+import Transport = Backend.Transport;
 export declare class ConnectionPool {
     readonly onDatagram: DatagramHandler;
     private _LastConnectionId;

package/lib/plugin/connectionPool.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { failure, nextTick, success } from '@4players/odin-common';
+import { failure, nextTick, success, } from '@4players/odin-common';
 import { ClockJumpCheckInterval, ClockJumpThreshold, logger } from './config';
 import { createMainConnection, } from './mainConnection';
 export class ConnectionPool {

package/lib/plugin/h3/mainConnection.d.ts

@@ -1,6 +1,5 @@
 import { ConnectionStatus, type DatagramHandler, type MainConnection } from '../mainConnection';
-import { MainCommands, MainNotifications, PeerId, Result } from '@4players/odin-common';
-import { Transport } from '..';
+import { MainCommands, MainNotifications, PeerId, Result, Backend } from '@4players/odin-common';
 import { Token } from '../token';
 import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
 export declare class H3MainConnection implements MainConnection {
@@ -13,7 +12,7 @@ export declare class H3MainConnection implements MainConnection {
     readonly closePromise: Promise<'closed'>;
     readonly datagramWriter: WritableStreamDefaultWriter<Uint8Array>;
     get closeSignal(): AbortSignal;
-    get transport(): Transport;
+    get transport(): Backend.Transport;
     get closed(): boolean;
     static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
     private constructor();

package/lib/plugin/h3/mainConnection.js

@@ -8,12 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ConnectionStatus, } from '../mainConnection';
-import { MainCommandsRpc, MainNotificationsRpc, RoomCommandsRpc, RoomNotificationsRpc, failure, success, } from '@4players/odin-common';
-import { logger, Transport } from '..';
+import { MainCommandsRpc, MainNotificationsRpc, RoomCommandsRpc, RoomNotificationsRpc, failure, success, Backend, } from '@4players/odin-common';
+import { logger } from '..';
 import { Token } from '../token';
 import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
 import { HealthCheckTimeout } from '../config';
 import * as pkg from '../../../package.json';
+var Transport = Backend.Transport;
 export class H3MainConnection {
     get closeSignal() {
         return this.closeController.signal;

package/lib/plugin/index.d.ts

@@ -7,6 +7,7 @@ import { VideoCapture } from './medias/video-capture';
 import { VideoPlayback } from './medias/video-playback';
 import { AudioPlayback } from './medias/audio-playback';
 import JoinRoomParameters = Backend.JoinRoomParameters;
+import Cipher = Backend.Cipher;
 export type { LogFilters } from '@4players/odin-common';
 export { logger } from './config';
 type Plugin = Backend.Plugin;
@@ -14,22 +15,15 @@ export interface DeviceParameters {
     readonly device?: Device;
     onStatusChanged?: Backend.OnStatusChanged;
 }
-export declare enum Transport {
-    H3 = "h3",
-    WebRTC = "webrtc"
-}
-export interface WebPluginOptions {
-    transport: Transport;
-}
 export declare class WebPlugin implements Plugin {
-    readonly options: WebPluginOptions;
-    readonly version = "2";
+    readonly version = "3";
+    readonly supportedTransports: Backend.Transport[];
     private _NextRoomId;
     private _PlaybackVolume;
     private readonly _ConnectionPool;
     private readonly _MediaController;
     get playbackVolume(): Backend.Volume;
-    static create(audioContextFactory: AudioContextFactory, options?: WebPluginOptions): Promise<WebPlugin>;
+    static create(audioContextFactory: AudioContextFactory): Promise<WebPlugin>;
     private constructor();
     joinRoom(parameters: JoinRoomParameters): Room;
     createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
@@ -50,9 +44,9 @@ export declare class Room implements Backend.Room {
     private readonly _Peers;
     private readonly _AvailableMediaIds;
     get mainConnection(): MainConnection | undefined;
-    constructor(id: number, connectionPool: ConnectionPool, parameters: JoinRoomParameters, options: WebPluginOptions);
+    constructor(id: number, connectionPool: ConnectionPool, parameters: JoinRoomParameters);
     get token(): string;
-    get cipher(): Backend.Cipher | undefined;
+    get cipher(): Cipher | undefined;
     request(method: string, properties: unknown): Promise<unknown>;
     link(media: Backend.Media): Promise<void>;
     unlink(media: Backend.Media): void;

package/lib/plugin/index.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { assert, generateUUID, OdinError, RoomNotificationsRpc, unwrap, } from '@4players/odin-common';
+import { assert, Backend, generateUUID, OdinError, RoomNotificationsRpc, unwrap, } from '@4players/odin-common';
 import { AudioContextCollection, MediaController, } from './mediaController';
 import { ConnectionPool } from './connectionPool';
 import { RoomConnection } from './roomConnection';
@@ -19,17 +19,13 @@ import { VideoCapture } from './medias/video-capture';
 import { VideoPlayback } from './medias/video-playback';
 import { AudioPlayback } from './medias/audio-playback';
 import { logger } from './config';
+var Transport = Backend.Transport;
 export { logger } from './config';
-export var Transport;
-(function (Transport) {
-    Transport["H3"] = "h3";
-    Transport["WebRTC"] = "webrtc";
-})(Transport || (Transport = {}));
 export class WebPlugin {
     get playbackVolume() {
         return this._PlaybackVolume;
     }
-    static create(audioContextFactory, options) {
+    static create(audioContextFactory) {
         return __awaiter(this, void 0, void 0, function* () {
             logger.info(['Other'], 'Using ODIN Plugin Web!');
             // eslint-disable-next-line prefer-const
@@ -37,19 +33,19 @@ export class WebPlugin {
             const pool = new ConnectionPool((connectionId, packet) => audioController.receivePacket(connectionId, packet));
             const audioContexts = new AudioContextCollection(audioContextFactory);
             audioController = new MediaController(audioContexts, pool.sendDatagram.bind(pool));
-            return new WebPlugin(pool, audioController, options);
+            return new WebPlugin(pool, audioController);
         });
     }
-    constructor(connectionPool, audioController, options = { transport: Transport.H3 }) {
-        this.options = options;
-        this.version = '2';
+    constructor(connectionPool, audioController) {
+        this.version = '3';
+        this.supportedTransports = [Transport.WebRTC, Transport.H3];
         this._NextRoomId = 0;
         this._PlaybackVolume = 1;
         this._ConnectionPool = connectionPool;
         this._MediaController = audioController;
     }
     joinRoom(parameters) {
-        return new Room(this._NextRoomId++, this._ConnectionPool, parameters, this.options);
+        return new Room(this._NextRoomId++, this._ConnectionPool, parameters);
     }
     createAudioPlayback(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -58,6 +54,7 @@ export class WebPlugin {
     }
     createAudioCapture(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('Eyvor createAudioCapture: ', parameters);
             return this._MediaController.createAudioCapture(parameters);
         });
     }
@@ -92,7 +89,7 @@ export class Room {
     get mainConnection() {
         return this._Connection.mainConnection;
     }
-    constructor(id, connectionPool, parameters, options) {
+    constructor(id, connectionPool, parameters) {
         var _a, _b, _c;
         this._Captures = new Map();
         this._Playbacks = new Map();
@@ -106,7 +103,7 @@ export class Room {
         assert(roomId !== undefined, 'room id required for multi-room-tokens');
         this._Id = id;
         this._OnEvent = onEvent;
-        this._Connection = new RoomConnection(connectionPool, options.transport, this._HandleEvent.bind(this), gateway ? new URL(gateway) : undefined, token, roomId, userData, position);
+        this._Connection = new RoomConnection(connectionPool, parameters.transport ? parameters.transport : Transport.H3, this._HandleEvent.bind(this), gateway ? new URL(gateway) : undefined, token, roomId, userData, position);
     }
     get token() {
         return this._Connection.token.text;
@@ -180,15 +177,19 @@ export class Room {
                 }
             }
             else if (media instanceof VideoPlayback) {
+                logger.log(['Video'], 'Room.link() VideoPlayback: ', media);
                 const entry = (_c = this._Playbacks.get(media.uid)) !== null && _c !== void 0 ? _c : {
                     media: undefined,
                     playback: undefined,
                 };
+                logger.log(['Video'], 'Room.link() VideoPlayback entry: ', entry);
                 if (entry.playback !== undefined) {
                     this.unlink(entry.playback);
                 }
                 if (entry.media !== undefined) {
+                    logger.log(['Video'], 'Room.link() VideoPlayback before startRemoteVideo: ', entry);
                     const track = yield ((_d = this.mainConnection) === null || _d === void 0 ? void 0 : _d.startRemoteVideo(entry.media.mediaId));
+                    logger.log(['Video'], 'Room.link() VideoPlayback track: ', track);
                     if (track) {
                         media.setMediaStream(new MediaStream([track]));
                     }

package/lib/plugin/mainConnection.d.ts

@@ -1,7 +1,7 @@
-import { Result } from '@4players/odin-common';
+import { Backend, Result } from '@4players/odin-common';
 import { Token } from './token';
-import { Transport } from './index';
 import { RpcConnection } from './rpcConnection';
+import Transport = Backend.Transport;
 export type DatagramHandler = (connectionId: number, datagram: Uint8Array) => void;
 export declare function createMainConnection(id: number, transport: Transport, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
 export declare enum ConnectionStatus {

package/lib/plugin/mainConnection.js

@@ -1,7 +1,9 @@
 /* eslint-disable no-dupe-class-members */
-import { logger, Transport } from './index';
+import { Backend } from '@4players/odin-common';
+import { logger } from './index';
 import { WebRtcMainConnection } from './webrtc/mainConnection';
 import { H3MainConnection } from './h3/mainConnection';
+var Transport = Backend.Transport;
 export function createMainConnection(id, transport, address, onDatagram, signal) {
     logger.log(['Connection'], 'createMainConnection() ', transport, address);
     switch (transport) {

package/lib/plugin/roomConnection.d.ts

@@ -2,7 +2,7 @@ import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
 import { Token } from './token';
-import { Transport } from './index';
+import Transport = Backend.Transport;
 export declare class RoomConnection implements RoomConnection {
     readonly connectionPool: ConnectionPool;
     readonly transport: Transport;

package/lib/plugin/webrtc/mainConnection.d.ts

@@ -1,8 +1,7 @@
-import { MainCommands, MainNotifications, Result } from '@4players/odin-common';
+import { MainCommands, MainNotifications, Result, Backend } from '@4players/odin-common';
 import { type MainConnection, type DatagramHandler, ConnectionStatus } from '../mainConnection';
 import { Token } from '../token';
 import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
-import { Transport } from '../index';
 export declare class WebRtcMainConnection implements MainConnection {
     readonly id: number;
     readonly address: string;
@@ -22,7 +21,7 @@ export declare class WebRtcMainConnection implements MainConnection {
     private _Negotiation;
     private _ResolveOffer?;
     private _awaitingRemoteTracks;
-    get transport(): Transport;
+    get transport(): Backend.Transport;
     get closePromise(): Promise<"closed">;
     get closeSignal(): AbortSignal;
     get closed(): boolean;

package/lib/plugin/webrtc/mainConnection.js

@@ -7,13 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, fail, } from '@4players/odin-common';
+import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, fail, Backend, } from '@4players/odin-common';
 import { ConnectionStatus, } from '../mainConnection';
 import { Token } from '../token';
 import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
 import { connect } from './websocket';
 import { HealthCheckTimeout, logger, MainConnectionPingInterval, WebRtcIceTimeout, WebRtcTimeout, } from '../config';
-import { Transport } from '../index';
+var Transport = Backend.Transport;
 export class WebRtcMainConnection {
     static create(id, address, onDatagram, signal) {
         return __awaiter(this, void 0, void 0, function* () {