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

package/lib/plugin/rpcConnection.js

@@ -0,0 +1,281 @@
+/* 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 { failure, success, msgpackEncode, msgpackDecode, MessagePackRpcSchema, } from '@4players/odin-common';
+import { getByteSize } from '../common/msgpack';
+export class RpcConnection {
+    get closed() {
+        return this._Close.signal.aborted;
+    }
+    get closeSignal() {
+        return this._Close.signal;
+    }
+    constructor(stream) {
+        this.stream = stream;
+        this._SendQueue = [];
+        this._RecvQueue = [];
+        this._EventQueue = [];
+        this._Requests = new Map();
+        this._Close = new AbortController();
+        this._NextId = 1;
+        if (stream instanceof WebSocket) {
+            stream.addEventListener('open', this._OnWebSocketOpen.bind(this));
+            stream.addEventListener('close', this.close.bind(this));
+            stream.addEventListener('message', (event) => this._OnRpcMessage(event.data));
+            stream.binaryType = 'arraybuffer';
+        }
+        else {
+            readRpcFromStream(stream.readable.getReader(), this._OnRpcMessage.bind(this))
+                .catch(console.error)
+                .finally(this.close.bind(this));
+            this._Writer = stream.writable.getWriter();
+        }
+        this._Close.signal.addEventListener('abort', this._Cleanup.bind(this), {
+            once: true,
+        });
+    }
+    request(name, properties, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.closed) {
+                return Promise.resolve('closed');
+            }
+            const id = this._NextId;
+            const timeoutId = timeout === undefined
+                ? undefined
+                : setTimeout(() => this._TimeoutRequest(id), timeout);
+            this._Send([0, id, name, properties]);
+            return new Promise((accept) => {
+                this._Requests.set(id, { accept, timeoutId });
+                this._NextId += 1;
+            });
+        });
+    }
+    notify(name, properties) {
+        if (!this.closed) {
+            this._Send([2, name, properties]);
+        }
+    }
+    recv() {
+        if (this.closed) {
+            return Promise.resolve('closed');
+        }
+        const event = this._EventQueue.shift();
+        if (event !== undefined) {
+            return Promise.resolve(event);
+        }
+        else {
+            return new Promise((accept) => this._RecvQueue.push(accept));
+        }
+    }
+    close() {
+        this._Close.abort();
+    }
+    _TimeoutRequest(requestId) {
+        const request = this._Requests.get(requestId);
+        if (request === undefined)
+            return;
+        this._Requests.delete(requestId);
+        clearTimeout(request.timeoutId);
+        request.accept('timeout');
+    }
+    _Send(message) {
+        const encoded = message instanceof Uint8Array
+            ? message
+            : new Uint8Array(msgpackEncode(message));
+        if (this.stream instanceof WebSocket) {
+            this.stream.send(encoded);
+        }
+        else {
+            this._Writer.write(encoded);
+        }
+    }
+    _OnWebSocketOpen(ev) {
+        for (const data of this._SendQueue) {
+            this._Send(data);
+        }
+        this._SendQueue.length = 0;
+    }
+    _OnRpcMessage(bytes) {
+        const rpc = parseRpc(bytes);
+        if (rpc.type !== 'Success') {
+            this.close();
+            return;
+        }
+        switch (rpc.value[0]) {
+            case 0:
+                this._Send([1, rpc.value[1], 'not supported', undefined]);
+                break;
+            case 1:
+                this._OnResponse(rpc.value[1], rpc.value[2], rpc.value[3]);
+                break;
+            case 2:
+                this._OnEvent(rpc.value[1], rpc.value[2]);
+                break;
+        }
+    }
+    _OnResponse(id, error, result) {
+        const request = this._Requests.get(id);
+        if (request === undefined)
+            return;
+        clearTimeout(request.timeoutId);
+        request.accept(error === null ? success(result) : failure(error));
+    }
+    _OnEvent(name, properties) {
+        const receiver = this._RecvQueue.shift();
+        if (receiver !== undefined) {
+            receiver({ name, properties });
+        }
+        else {
+            this._EventQueue.push({ name, properties });
+        }
+    }
+    _Cleanup() {
+        var _a;
+        for (const request of this._Requests.values()) {
+            clearTimeout(request.timeoutId);
+            request.accept('closed');
+        }
+        this._Requests.clear();
+        for (const accept of this._RecvQueue) {
+            accept('closed');
+        }
+        this._RecvQueue.length = 0;
+        this._SendQueue.length = 0;
+        if (this.stream instanceof WebSocket) {
+            this.stream.close();
+        }
+        else {
+            (_a = this._Writer) === null || _a === void 0 ? void 0 : _a.close().catch(() => {
+                /* drop silently */
+            });
+        }
+    }
+}
+export class TypedRpcConnection {
+    get closed() {
+        return this.rpcConnection.closed;
+    }
+    get closeSignal() {
+        return this.rpcConnection.closeSignal;
+    }
+    constructor(rpcConnection, _Commands, _Events) {
+        this.rpcConnection = rpcConnection;
+        this._Commands = _Commands;
+        this._Events = _Events;
+    }
+    request(name, properties, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            properties = this._Commands[name].request.parse(properties);
+            const response = yield (timeout !== undefined
+                ? this.rpcConnection.request(name, properties, timeout)
+                : this.rpcConnection.request(name, properties));
+            if (response === 'closed' ||
+                response === 'timeout' ||
+                response.type === 'Failure') {
+                return response;
+            }
+            const parsed = this._Commands[name].response.safeParse(response.value);
+            if (parsed.success) {
+                response.value = parsed.data;
+                return response;
+            }
+            else {
+                return failure(`response schema failed validation: ${parsed.error}`);
+            }
+        });
+    }
+    notify(name, properties) {
+        properties = this._Commands[name].request.parse(properties);
+        this.rpcConnection.notify(name, properties);
+    }
+    recv() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const event = yield this.rpcConnection.recv();
+            if (event === 'closed')
+                return event;
+            const parsed = parseRpcMessage(this._Events, event);
+            if (parsed !== undefined) {
+                return parsed;
+            }
+            if (!isKnownRpcMessage(this._Events, event.name)) {
+                console.warn(`dropping unknown event ${event.name}`);
+            }
+            else {
+                console.error(`schema validation for ${event.name} failed; closing connection`);
+                this.rpcConnection.close();
+            }
+            return 'closed';
+        });
+    }
+    close() {
+        this.rpcConnection.close();
+    }
+}
+export function parseRpc(buffer) {
+    try {
+        return success(MessagePackRpcSchema.parse(msgpackDecode(buffer)));
+    }
+    catch (error) {
+        return failure(String(error));
+    }
+}
+export function parseRpcMessage(events, rpc) {
+    if (!isKnownRpcMessage(events, rpc.name))
+        return undefined;
+    const parsed = events[rpc.name].safeParse(rpc.properties);
+    if (!parsed.success) {
+        return undefined;
+    }
+    return {
+        name: rpc.name,
+        properties: parsed.data,
+    };
+}
+export function isKnownRpcMessage(events, name) {
+    return name in events;
+}
+function readRpcFromStream(reader, onRpc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let buffer = new Uint8Array();
+        for (;;) {
+            let read;
+            try {
+                read = yield reader.read();
+            }
+            catch (error) {
+                break;
+            }
+            if (read.done)
+                break;
+            buffer = mergeBuffer(buffer, read.value);
+            let offset = 0;
+            for (let size;; offset += size) {
+                size = getByteSize(buffer, offset);
+                if (!size || offset + buffer.length < size)
+                    break;
+                onRpc(buffer.subarray(offset, offset + size));
+            }
+            buffer = buffer.subarray(offset);
+        }
+        if (buffer.length > 0) {
+            console.warn('unprocessed bytes left in rpc stream', buffer);
+        }
+    });
+}
+function mergeBuffer(a, b) {
+    if (a.length === 0)
+        return b;
+    if (b.length === 0)
+        return a;
+    const merged = new Uint8Array(a.length + b.length);
+    merged.set(a, 0);
+    merged.set(b, a.length);
+    return merged;
+}

package/lib/plugin/token.d.ts

@@ -0,0 +1,13 @@
+import { TokenAudienceSchema, TokenClaims, Result, Infer } from '@4players/odin-common';
+export declare class Token {
+    readonly text: string;
+    readonly claims: TokenClaims;
+    static parse(token: string): Result<Token>;
+    private readonly _Upstream;
+    protected constructor(text: string, claims: TokenClaims);
+    get timeLeft(): number;
+    get upstream(): Token | undefined;
+    get defaultRoomId(): string | undefined;
+    hasAudience(audience: Infer<typeof TokenAudienceSchema>): boolean;
+    toString(): string;
+}

package/lib/plugin/token.js

@@ -0,0 +1,66 @@
+import { TokenClaimsSchema, failure, fromBase64Url, success, } from '@4players/odin-common';
+export class Token {
+    static parse(token) {
+        const segments = token.split('.');
+        if (segments.length !== 3)
+            return failure('expected three segments');
+        const body = fromBase64Url(segments[1]);
+        if (body.type === 'Failure') {
+            return failure(`invalid token; ${body.reason}`);
+        }
+        let json;
+        try {
+            json = JSON.parse(body.value);
+        }
+        catch (reason) {
+            return failure(`invalid token; ${reason}`);
+        }
+        const parsed = TokenClaimsSchema.safeParse(json);
+        if (parsed.success === false) {
+            return failure(`invalid token; ${parsed.error}`);
+        }
+        return success(new Token(token, parsed.data));
+    }
+    constructor(text, claims) {
+        this.text = text;
+        this.claims = claims;
+        if (claims.ups !== undefined) {
+            const upstream = Token.parse(claims.ups);
+            if (upstream.type === 'Success') {
+                this._Upstream = upstream.value;
+            }
+            else {
+                console.error(`upstream in token can not be parsed; ${upstream.reason}`);
+            }
+        }
+    }
+    get timeLeft() {
+        if (this.claims.exp === undefined)
+            return Infinity;
+        return this.claims.exp * 1000 - Date.now();
+    }
+    get upstream() {
+        return this._Upstream;
+    }
+    get defaultRoomId() {
+        if (Array.isArray(this.claims.rid)) {
+            return this.claims.rid.length === 1 ? this.claims.rid[0] : undefined;
+        }
+        else {
+            return this.claims.rid;
+        }
+    }
+    hasAudience(audience) {
+        if (this.claims.aud === undefined)
+            return true;
+        if (Array.isArray(this.claims.aud)) {
+            return this.claims.aud.includes(audience);
+        }
+        else {
+            return this.claims.aud === audience;
+        }
+    }
+    toString() {
+        return this.text;
+    }
+}

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

@@ -0,0 +1,52 @@
+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';
+export declare class WebRtcMainConnection implements MainConnection {
+    readonly id: number;
+    readonly address: string;
+    readonly url: URL;
+    readonly onDatagram: DatagramHandler;
+    readonly connection: TypedRpcConnection<MainCommands, MainNotifications>;
+    readonly webRtc: RTCPeerConnection;
+    static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
+    private readonly _AudioChannel;
+    private readonly _PeerIdMap;
+    private _PeriodicHealthCheck;
+    private _WebRtcIceTimeout;
+    private _WebRtcTimeout;
+    private _ClosePromise;
+    private _LocalVideos;
+    private _RemoteVideos;
+    private _Negotiation;
+    private _ResolveOffer?;
+    private _awaitingRemoteTracks;
+    get transport(): Backend.Transport;
+    get closePromise(): Promise<"closed">;
+    get closeSignal(): AbortSignal;
+    get closed(): boolean;
+    get status(): ConnectionStatus;
+    waitForConnected(): Promise<void>;
+    private constructor();
+    close(): void;
+    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<Result<RpcConnection> | 'closed'>;
+    getReconnectToken(peerId: number): Promise<Result<Token>>;
+    sendDatagram(datagram: Uint8Array): void;
+    healthCheck(): Promise<boolean>;
+    private _Request;
+    private _readWebRtcUpdate;
+    private _SendOffer;
+    private _OnWebRtcStatusChanged;
+    private _OnWebRtcUpdate;
+    private _UpdateRemoteSdp;
+    private _AddIceCandidate;
+    private _OnIceCandidate;
+    private ensureTransceivers;
+    startLocalVideo(mediaId: number, track: MediaStreamTrack): Promise<void>;
+    stopLocalVideo(mediaId: number): void;
+    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
+    stopRemoteVideo(mediaId: number): void;
+    private onTrack;
+    requestNegotiation(waitForAnswer: boolean): void;
+    private _CleanUp;
+}