@4players/odin-plugin-web 1.0.0-alpha.9 → 1.0.1

package/lib/plugin/config.js

@@ -1,10 +0,0 @@
-export const HealthCheckTimeout = 1000; /* ms */
-export const ClockJumpCheckInterval = 1000; /* ms */
-export const ClockJumpThreshold = 10000; /* ms */
-export const MainConnectionPingInterval = 10000; /* ms */
-export const WebRTCIceTimeout = 3000; /* ms */
-export const WebRTCTimeout = 10000; /* ms */
-export const ConnectTimeout = 5000; /* ms */
-export const MinTokenLifetime = 60000; /* 1min */
-export const MinTokenRefreshInterval = 5000; /* 5sec */
-export const ConnectInterval = [0, 100, 200, 200, 500, 1000, 2000]; /* ms */

package/lib/plugin/connectionPool.d.ts

@@ -1,16 +0,0 @@
-import { DatagramHandler, MainConnection } from './mainConnection';
-import { Result } from '@4players/odin-common';
-export declare class ConnectionPool {
-    readonly onDatagram: DatagramHandler;
-    private _LastConnectionId;
-    private readonly _ConnectionsByUrl;
-    private readonly _ConnectionsById;
-    private readonly _Close;
-    get closed(): boolean;
-    constructor(onDatagram: DatagramHandler);
-    sendDatagram(connectionId: number, packet: Uint8Array): void;
-    acquireConnection(url: URL, signal: AbortSignal): Promise<Result<MainConnection> | 'closed'>;
-    releaseConnection(connection: MainConnection): void;
-    checkHealth(): Promise<void>;
-    close(): void;
-}

package/lib/plugin/connectionPool.js

@@ -1,110 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { ClockJumpCheckInterval, ClockJumpThreshold } from './config';
-import { MainConnection } from './mainConnection';
-import { failure, nextTick, success } from '@4players/odin-common';
-export class ConnectionPool {
-    get closed() {
-        return this._Close.signal.aborted;
-    }
-    constructor(onDatagram) {
-        this.onDatagram = onDatagram;
-        this._LastConnectionId = 0;
-        this._ConnectionsByUrl = new Map();
-        this._ConnectionsById = new Map();
-        this._Close = new AbortController();
-        let lastCheckAt = Date.now();
-        const clockJumpDetector = setInterval(() => {
-            const elapsed = Math.abs(Date.now() - lastCheckAt);
-            if (elapsed > ClockJumpThreshold)
-                this.checkHealth();
-            lastCheckAt = Date.now();
-        }, ClockJumpCheckInterval);
-        addEventListener('offline', () => this.checkHealth(), {
-            signal: this._Close.signal,
-        });
-        this._Close.signal.addEventListener('abort', () => {
-            clearInterval(clockJumpDetector);
-            for (const entry of this._ConnectionsById.values()) {
-                if (entry.status === 'ready') {
-                    entry.connection.close();
-                }
-            }
-            this._ConnectionsById.clear();
-            this._ConnectionsByUrl.clear();
-        }, { once: true });
-    }
-    sendDatagram(connectionId, packet) {
-        const connection = this._ConnectionsById.get(connectionId);
-        if (connection !== undefined && connection.status === 'ready') {
-            connection.connection.sendDatagram(packet);
-        }
-    }
-    acquireConnection(url, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield nextTick(); // slow down acquireConnection
-            if (this.closed)
-                return 'closed';
-            let entry = this._ConnectionsByUrl.get(url);
-            if (entry === undefined ||
-                (entry.status === 'ready' && entry.connection.closed)) {
-                const id = this._LastConnectionId++;
-                const promise = MainConnection.create(id, url, this.onDatagram, signal);
-                entry = { status: 'init', id, promise };
-                this._ConnectionsByUrl.set(url, entry);
-                this._ConnectionsById.set(id, entry);
-                const connection = yield promise;
-                if (connection.type !== 'Success') {
-                    this._ConnectionsByUrl.delete(url);
-                    this._ConnectionsById.delete(id);
-                    return connection;
-                }
-                entry = { status: 'ready', connection: connection.value, references: 1 };
-                this._ConnectionsByUrl.set(url, entry);
-                this._ConnectionsById.set(id, entry);
-                return success(entry.connection);
-            }
-            else if (entry.status === 'init') {
-                const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(), { once: true }));
-                const result = yield Promise.race([entry.promise, onAbort]);
-                if (result === undefined)
-                    return failure('aborted');
-                return result;
-            }
-            else {
-                entry.references += 1;
-                return success(entry.connection);
-            }
-        });
-    }
-    releaseConnection(connection) {
-        const entry = this._ConnectionsById.get(connection.id);
-        if (entry === undefined)
-            return;
-        if (entry.status === 'init') {
-            console.error('released connection before it was acquired!');
-            return;
-        }
-        entry.references -= 1;
-        if (entry.references === 0) {
-            entry.connection.close();
-            this._ConnectionsByUrl.delete(connection.url);
-            this._ConnectionsById.delete(connection.id);
-        }
-    }
-    checkHealth() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(Array.from(this._ConnectionsById.values()).map((entry) => entry.status === 'ready' ? entry.connection.healthCheck() : undefined));
-        });
-    }
-    close() {
-        this._Close.abort();
-    }
-}

package/lib/plugin/mainConnection.d.ts

@@ -1,39 +0,0 @@
-import { TypedRpcConnection } from './rpcConnection';
-import { Token } from './token';
-import { MainCommands, MainNotifications, Result } from '@4players/odin-common';
-type RpcConnection = TypedRpcConnection<MainCommands, MainNotifications>;
-export type DatagramHandler = (connectionId: number, datagram: Uint8Array) => void;
-export declare class MainConnection {
-    readonly id: number;
-    readonly url: URL;
-    readonly onDatagram: DatagramHandler;
-    readonly connection: RpcConnection;
-    readonly webRtc: RTCPeerConnection;
-    static create(id: number, url: URL, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
-    private readonly _AudioChannel;
-    private readonly _PeerIdMap;
-    private _PeriodicHealthCheck;
-    private _WebRtcIceTimeout;
-    private _WebRtcTimeout;
-    private _ClosePromise;
-    get closePromise(): Promise<"closed">;
-    get closeSignal(): AbortSignal;
-    get closed(): boolean;
-    webRtcReady(): Promise<boolean>;
-    private constructor();
-    close(): void;
-    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<Result<WebSocket> | 'closed'>;
-    getReconnectToken(webSocket: WebSocket): Promise<Result<Token>>;
-    sendDatagram(datagram: Uint8Array): void;
-    healthCheck(): Promise<boolean>;
-    private _Request;
-    private _readEvents;
-    private _SendOffer;
-    private _OnWebRtcStatusChanged;
-    private _OnWebRtcUpdate;
-    private _UpdateRemoteSdp;
-    private _AddIceCandidate;
-    private _OnIceCandidate;
-    private _CleanUp;
-}
-export {};

package/lib/plugin/mainConnection.js

@@ -1,293 +0,0 @@
-/* eslint-disable no-dupe-class-members */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { HealthCheckTimeout, MainConnectionPingInterval, WebRTCIceTimeout as WebRtcIceTimeout, WebRTCTimeout as WebRtcTimeout, } from './config';
-import { TypedRpcConnection, connect } from './rpcConnection';
-import { Token } from './token';
-import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, } from '@4players/odin-common';
-export class MainConnection {
-    static create(id, url, onDatagram, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (signal.aborted)
-                return failure('aborted');
-            const webSocketUrl = extendUrl(url, 'main');
-            if (webSocketUrl.type !== 'Success')
-                return webSocketUrl;
-            const webSocket = yield connect(webSocketUrl.value, signal);
-            if (webSocket.type !== 'Success')
-                return webSocket;
-            const connection = new TypedRpcConnection(webSocket.value, MainCommandsRpc, MainNotificationsRpc);
-            let webRtc;
-            try {
-                webRtc = new RTCPeerConnection();
-            }
-            catch (reason) {
-                connection.close();
-                return failure(`unable to create webrtc connection; ${reason}`);
-            }
-            return success(new MainConnection(id, url, onDatagram, connection, webRtc));
-        });
-    }
-    get closePromise() {
-        return this._ClosePromise;
-    }
-    get closeSignal() {
-        return this.connection.closeSignal;
-    }
-    get closed() {
-        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);
-                }
-            };
-            this.webRtc.addEventListener('connectionstatechange', onConnectionStateChanged);
-        });
-    }
-    constructor(id, url, onDatagram, connection, webRtc) {
-        this.id = id;
-        this.url = url;
-        this.onDatagram = onDatagram;
-        this.connection = connection;
-        this.webRtc = webRtc;
-        this._PeerIdMap = new WeakMap();
-        this.closeSignal.addEventListener('abort', () => this._CleanUp(), {
-            once: true,
-        });
-        this._ClosePromise = new Promise((accept) => {
-            this.closeSignal.addEventListener('abort', () => accept('closed'), {
-                once: true,
-            });
-        });
-        this._AudioChannel = this.webRtc.createDataChannel('audio', {
-            id: 2,
-            negotiated: true,
-            ordered: false,
-            maxRetransmits: 0,
-        });
-        this._AudioChannel.binaryType = 'arraybuffer';
-        this._AudioChannel.onmessage = (event) => onDatagram(this.id, new Uint8Array(event.data));
-        this.webRtc.onicecandidate = this._OnIceCandidate.bind(this);
-        this.webRtc.onconnectionstatechange = () => this._OnWebRtcStatusChanged();
-        this._SendOffer();
-        if (MainConnectionPingInterval !== undefined) {
-            this._PeriodicHealthCheck = setInterval(() => this.healthCheck(), MainConnectionPingInterval);
-        }
-        this._readEvents();
-    }
-    close() {
-        this.connection.close();
-    }
-    joinRoom(token, roomId, userData, position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.connection.request('JoinRoom', {
-                token: String(token),
-                room_id: roomId,
-                user_data: userData,
-                position,
-            });
-            if (response === 'closed' || response.type === 'Failure')
-                return response;
-            const responseValue = response.value;
-            if (!('token' in responseValue)) {
-                return failure('JoinRoom responded without token');
-            }
-            const url = extendUrl(this.url, `room?token=${responseValue.token}`);
-            if (url.type === 'Failure')
-                return url;
-            const webSocket = yield connect(url.value, this.closeSignal);
-            if (webSocket.type === 'Success') {
-                this._PeerIdMap.set(webSocket.value, responseValue.peer_id);
-            }
-            return webSocket;
-        });
-    }
-    getReconnectToken(webSocket) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const peerId = this._PeerIdMap.get(webSocket);
-            if (peerId === undefined) {
-                return failure('the webSocket is not part of this connection');
-            }
-            const response = yield this._Request('RequestReconnectToken', {
-                peer_id: peerId,
-            });
-            if (response.type === 'Failure')
-                return response;
-            return Token.parse(response.value);
-        });
-    }
-    sendDatagram(datagram) {
-        if (this._AudioChannel.readyState === 'open') {
-            this._AudioChannel.send(datagram);
-        }
-    }
-    healthCheck() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this._Request('Ping', {}, HealthCheckTimeout);
-            const success = response !== 'timeout' && response.type === 'Success';
-            if (!success)
-                this.close();
-            return success;
-        });
-    }
-    _Request(name, properties, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield (timeout === undefined
-                ? this.connection.request(name, properties)
-                : this.connection.request(name, properties, timeout));
-            if (result === 'closed')
-                return failure('connection lost');
-            return result;
-        });
-    }
-    _readEvents() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (true) {
-                const event = yield this.connection.recv();
-                if (event === 'closed')
-                    break;
-                console.debug(`${this.url} received ${event.name} on main`, event.properties);
-                if (event.name === 'WebRtcUpdate') {
-                    this._OnWebRtcUpdate(event.properties);
-                }
-            }
-            this.close();
-        });
-    }
-    _SendOffer() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let sdp;
-            try {
-                const offer = yield this.webRtc.createOffer();
-                assert(offer.type === 'offer' && offer.sdp, 'generated broken webrtc offer');
-                yield this.webRtc.setLocalDescription(offer);
-                sdp = (_a = offer.sdp) !== null && _a !== void 0 ? _a : '';
-            }
-            catch (_b) {
-                console.error('RTCPeerConnection failed creating an offer');
-                return;
-            }
-            yield this._Request('WebRtcUpdate', {
-                kind: 'Sdp',
-                type: 'Offer',
-                sdp,
-                media_map: [],
-            });
-        });
-    }
-    _OnWebRtcStatusChanged() {
-        console.log(`webrtc ${this.webRtc.connectionState}`);
-        switch (this.webRtc.connectionState) {
-            case 'closed':
-            case 'failed':
-                this.close();
-                break;
-            case 'connected':
-                clearTimeout(this._WebRtcIceTimeout);
-                this._WebRtcIceTimeout = undefined;
-                clearTimeout(this._WebRtcTimeout);
-                this._WebRtcTimeout = undefined;
-                break;
-            case 'disconnected':
-                this.healthCheck();
-            // falls through
-            default:
-                if (this._WebRtcIceTimeout === undefined) {
-                    this._WebRtcIceTimeout = setTimeout(() => {
-                        this.webRtc.restartIce();
-                        this._WebRtcIceTimeout = undefined;
-                    }, WebRtcIceTimeout);
-                }
-                if (this._WebRtcTimeout === undefined) {
-                    this._WebRtcTimeout = setTimeout(() => this.close(), WebRtcTimeout);
-                }
-                break;
-        }
-    }
-    _OnWebRtcUpdate(update) {
-        switch (update.kind) {
-            case 'Sdp':
-                this._UpdateRemoteSdp(update);
-                break;
-            case 'Trickle':
-                this._AddIceCandidate(update);
-                break;
-            case 'TrickleFinished':
-                this.webRtc.addIceCandidate(undefined);
-                break;
-        }
-    }
-    _UpdateRemoteSdp(update) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const type = update.type === 'Answer' ? 'answer' : 'offer';
-            yield this.webRtc.setRemoteDescription({ type, sdp: update.sdp });
-        });
-    }
-    _AddIceCandidate(candidate) {
-        var _a, _b, _c;
-        const candidateInit = {
-            candidate: candidate.candidate,
-            sdpMid: (_a = candidate.spd_mid) !== null && _a !== void 0 ? _a : undefined,
-            sdpMLineIndex: (_b = candidate.spd_mline_index) !== null && _b !== void 0 ? _b : undefined,
-            usernameFragment: (_c = candidate.username_fragment) !== null && _c !== void 0 ? _c : undefined,
-        };
-        // HACK/TODO(max): find out why the server is not sending sdpMid or sdpMLineIndex
-        if (candidateInit.sdpMid === undefined &&
-            candidateInit.sdpMLineIndex === undefined) {
-            candidateInit.sdpMid = '0';
-        }
-        this.webRtc.addIceCandidate(candidateInit);
-    }
-    _OnIceCandidate(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.candidate) {
-                const { candidate, sdpMid, sdpMLineIndex, usernameFragment } = event.candidate;
-                this._Request('WebRtcUpdate', {
-                    kind: 'Trickle',
-                    candidate,
-                    spd_mid: sdpMid !== null && sdpMid !== void 0 ? sdpMid : undefined,
-                    spd_mline_index: sdpMLineIndex !== null && sdpMLineIndex !== void 0 ? sdpMLineIndex : undefined,
-                    username_fragment: usernameFragment !== null && usernameFragment !== void 0 ? usernameFragment : undefined,
-                });
-            }
-            else {
-                this._Request('WebRtcUpdate', { kind: 'TrickleFinished' });
-            }
-        });
-    }
-    _CleanUp() {
-        console.debug(`${this.url} closed`);
-        this.connection.close();
-        this.webRtc.close();
-        clearInterval(this._PeriodicHealthCheck);
-        clearTimeout(this._WebRtcIceTimeout);
-        clearTimeout(this._WebRtcTimeout);
-    }
-}

package/lib/plugin/roomConnection.d.ts

@@ -1,36 +0,0 @@
-import { ConnectionPool } from './connectionPool';
-import { MainConnection } from './mainConnection';
-import { Token } from './token';
-import { Backend, RoomCommands, Result } from '@4players/odin-common';
-import * as z from 'zod';
-export declare class RoomConnection {
-    readonly connectionPool: ConnectionPool;
-    readonly onEvent: Backend.OnEvent;
-    readonly gateway: URL | undefined;
-    readonly roomId: string;
-    private _RoomConnection;
-    private _MainConnection;
-    private readonly _Close;
-    private _Token;
-    private _UserData;
-    private _Position;
-    private _LastTokenRenew;
-    private readonly _Closed;
-    get token(): Token;
-    get userData(): Uint8Array;
-    get position(): [number, number, number];
-    get closed(): boolean;
-    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'>;
-    close(): void;
-    get renewTokenIn(): number;
-    private _Main;
-    private _ConnectToServer;
-    private _ChangeStatus;
-    private _HandleConnection;
-    private _HandleEvent;
-    private _HandleRequests;
-    private _RenewToken;
-}