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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4players/odin-plugin-web",
-  "version": "1.0.0-alpha.20",
+  "version": "1.0.0-alpha.21",
   "description": "A backend plugin providing the custom WebAssembly audio processing module for ODIN web clients",
   "homepage": "https://www.4players.io",
   "repository": {
@@ -12,33 +12,36 @@
   "types": "./lib/plugin/index.d.ts",
   "scripts": {
     "clean": "rimraf build lib",
-    "configure": "npm-run-all -pl configure:*",
+    "configure": "npm-run-all configure:*",
     "configure:shared": "emcmake cmake -B build/shared -DCMAKE_BUILD_TYPE=Release -DSHARED_MEMORY=1 -S .",
     "configure:unshared": "emcmake cmake -B build/unshared -DCMAKE_BUILD_TYPE=Release -S .",
-    "build": "npm-run-all -s configure build:wasm build:plugin build:worker",
-    "build:wasm": "npm-run-all -pl build:wasm:* && node install-wasm.js",
-    "build:wasm:shared": "emmake cmake --build build/shared",
-    "build:wasm:unshared": "emmake cmake --build build/unshared",
-    "build:worker": "ts-node src/build.ts && tsc -b ./tsconfig.worker.json",
-    "build:plugin": "tsc --build --verbose --force",
+    "build": "npm-run-all -s configure build:genversion build:wasm build:bundle build:types",
+    "build:genversion": "genversion -se src/common/version.ts",
+    "build:wasm": "npm-run-all -pl build:wasm:*",
+    "build:wasm:shared": "emmake cmake --build build/shared -j 8",
+    "build:wasm:unshared": "emmake cmake --build build/unshared -j 8",
+    "build:bundle": "ts-node src/bundle.ts",
+    "build:types": "dts-bundle-generator --fail-on-class --no-banner -o lib/plugin/index.d.ts src/plugin/index.ts",
     "format": "prettier 'src/**/*.ts' --write",
     "lint": "eslint . --ext .ts",
     "test": "npm --prefix test run start",
     "bundle": "npm run build && esbuild lib/plugin/index.js --bundle --outfile=dist/plugin.js"
   },
   "dependencies": {
-  "@4players/odin-common": "~2.7.0"
+    "@4players/odin-common": "~2.8.0"
   },
   "devDependencies": {
     "@types/node": "~20.14.0",
     "@typescript-eslint/eslint-plugin": "~7.16.0",
     "@typescript-eslint/parser": "~7.16.0",
+    "dts-bundle-generator": "^9.5.1",
     "esbuild": "~0.23.0",
     "eslint": "~8.57.0",
     "eslint-config-semistandard": "~17.0.0",
     "eslint-plugin-import": "~2.29.0",
     "eslint-plugin-node": "~11.1.0",
     "eslint-plugin-promise": "~6.1.0",
+    "genversion": "^3.2.0",
     "npm-run-all2": "~6.1.0",
     "prettier": "~3.3.0",
     "rimraf": "~5.0.0",

package/lib/common/msgpack.d.ts

@@ -1,2 +0,0 @@
-export declare function getByteSize(buffer: Uint8Array, offset: number): number | undefined;
-export declare function getNextOffset(buffer: Uint8Array, offset: number): number | undefined;

package/lib/common/msgpack.js

@@ -1,117 +0,0 @@
-export function getByteSize(buffer, offset) {
-    const nextOffset = getNextOffset(buffer, offset);
-    return nextOffset !== undefined ? nextOffset - offset : undefined;
-}
-export function getNextOffset(buffer, offset) {
-    if (offset >= buffer.length)
-        return undefined;
-    const tag = buffer[offset++];
-    switch (tag) {
-        case 0xc0:
-        case 0xc2:
-        case 0xc3:
-            return offset;
-        case 0xc4:
-            return skipBytes(buffer, offset + 1, read8bit(buffer, offset));
-        case 0xc5:
-            return skipBytes(buffer, offset + 2, read16bit(buffer, offset));
-        case 0xc6:
-            return skipBytes(buffer, offset + 4, read32bit(buffer, offset));
-        case 0xc7:
-            return skipBytes(buffer, offset + 2, read8bit(buffer, offset));
-        case 0xc8:
-            return skipBytes(buffer, offset + 3, read16bit(buffer, offset));
-        case 0xc9:
-            return skipBytes(buffer, offset + 5, read32bit(buffer, offset));
-        case 0xca:
-            return skipBytes(buffer, offset, 4);
-        case 0xcb:
-            return skipBytes(buffer, offset, 8);
-        case 0xcc:
-            return skipBytes(buffer, offset, 1);
-        case 0xcd:
-            return skipBytes(buffer, offset, 2);
-        case 0xce:
-            return skipBytes(buffer, offset, 4);
-        case 0xcf:
-            return skipBytes(buffer, offset, 8);
-        case 0xd0:
-            return skipBytes(buffer, offset, 1);
-        case 0xd1:
-            return skipBytes(buffer, offset, 2);
-        case 0xd2:
-            return skipBytes(buffer, offset, 4);
-        case 0xd3:
-            return skipBytes(buffer, offset, 8);
-        case 0xd4:
-            return skipBytes(buffer, offset, 2);
-        case 0xd5:
-            return skipBytes(buffer, offset, 3);
-        case 0xd6:
-            return skipBytes(buffer, offset, 5);
-        case 0xd7:
-            return skipBytes(buffer, offset, 9);
-        case 0xd8:
-            return skipBytes(buffer, offset, 17);
-        case 0xd9:
-            return skipBytes(buffer, offset + 1, read8bit(buffer, offset));
-        case 0xda:
-            return skipBytes(buffer, offset + 2, read16bit(buffer, offset));
-        case 0xdb:
-            return skipBytes(buffer, offset + 4, read32bit(buffer, offset));
-        case 0xdc:
-            return skipObjects(buffer, offset + 2, read16bit(buffer, offset));
-        case 0xdd:
-            return skipObjects(buffer, offset + 4, read32bit(buffer, offset));
-        case 0xde:
-            return skipObjects(buffer, offset + 2, read16bit(buffer, offset) * 2);
-        case 0xdf:
-            return skipObjects(buffer, offset + 4, read32bit(buffer, offset) * 2);
-        default:
-            if ((tag & 0x80) === 0x00)
-                return offset;
-            if ((tag & 0xf0) === 0x80) {
-                return skipObjects(buffer, offset, (tag & 0x0f) * 2);
-            }
-            if ((tag & 0xf0) === 0x90)
-                return skipObjects(buffer, offset, tag & 0x0f);
-            if ((tag & 0xe0) === 0xa0)
-                return skipBytes(buffer, offset, tag & 0x1f);
-            if ((tag & 0xe0) === 0xe0)
-                return offset;
-            throw new Error('invalid msgpack');
-    }
-}
-function skipBytes(buffer, offset, bytes) {
-    const newOffset = offset + bytes;
-    return isFinite(newOffset) ? newOffset : undefined;
-}
-function skipObjects(buffer, offset, objects) {
-    if (!isFinite(objects))
-        return undefined;
-    for (let i = 0; i < objects; i++) {
-        const newOffset = getNextOffset(buffer, offset);
-        if (newOffset === undefined)
-            return undefined;
-        offset = newOffset;
-    }
-    return offset;
-}
-function read8bit(bytes, offset) {
-    if (offset > bytes.length)
-        return NaN;
-    return bytes[offset];
-}
-function read16bit(bytes, offset) {
-    if (offset + 2 > bytes.length)
-        return NaN;
-    return (bytes[offset] << 8) | bytes[offset + 1];
-}
-function read32bit(bytes, offset) {
-    if (offset + 4 > bytes.length)
-        return NaN;
-    return ((bytes[offset] << 24) |
-        (bytes[offset + 1] << 16) |
-        (bytes[offset + 2] << 8) |
-        bytes[offset + 3]);
-}

package/lib/plugin/config.d.ts

@@ -1,12 +0,0 @@
-import { Logger } from '@4players/odin-common';
-export declare const HealthCheckTimeout = 1000;
-export declare const ClockJumpCheckInterval = 1000;
-export declare const ClockJumpThreshold = 10000;
-export declare const MainConnectionPingInterval: undefined;
-export declare const WebRtcIceTimeout = 3000;
-export declare const WebRtcTimeout = 10000;
-export declare const ConnectTimeout = 5000;
-export declare const MinTokenLifetime = 60000;
-export declare const MinTokenRefreshInterval = 5000;
-export declare const ConnectInterval: number[];
-export declare const logger: Logger;

package/lib/plugin/config.js

@@ -1,22 +0,0 @@
-import { Logger } from '@4players/odin-common';
-export const HealthCheckTimeout = 1000; /* ms */
-export const ClockJumpCheckInterval = 1000; /* ms */
-export const ClockJumpThreshold = 10000; /* ms */
-export const MainConnectionPingInterval = undefined; /* disabled, was 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 */
-let loggerInstance;
-const projectName = 'odin-plugin-web';
-function createLogger() {
-    return new Logger(projectName, {
-        tags: [],
-    });
-}
-if (!loggerInstance) {
-    loggerInstance = createLogger();
-}
-export const logger = loggerInstance;

package/lib/plugin/connectionPool.d.ts

@@ -1,17 +0,0 @@
-import { Result } from '@4players/odin-common';
-import { DatagramHandler, MainConnection } from './mainConnection';
-import { Transport } from './index';
-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(transport: Transport, address: string, signal: AbortSignal): Promise<Result<MainConnection> | 'closed'>;
-    releaseConnection(connection: MainConnection): void;
-    checkHealth(): Promise<void>;
-    close(): void;
-}

package/lib/plugin/connectionPool.js

@@ -1,130 +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 { failure, nextTick, success } from '@4players/odin-common';
-import { ClockJumpCheckInterval, ClockJumpThreshold, logger } from './config';
-import { createMainConnection, } from './mainConnection';
-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(transport, address, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger.log(['Connection'], 'ConnectionPool.acquireConnection(): transport, address', transport, address);
-            yield nextTick(); // slow down acquireConnection
-            if (this.closed)
-                return 'closed';
-            const key = create_connection_key(transport, address);
-            let entry = this._ConnectionsByUrl.get(key);
-            if (entry === undefined ||
-                (entry.status === 'ready' && entry.connection.closed)) {
-                // Create a new Connection
-                const id = this._LastConnectionId++;
-                const promise = createMainConnection(id, transport, address, this.onDatagram, signal);
-                entry = { status: 'init', id, promise, references: 1 };
-                this._ConnectionsByUrl.set(key, entry);
-                this._ConnectionsById.set(id, entry);
-                const connection = yield promise;
-                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): MainConnection resolved.', connection);
-                if (connection.type !== 'Success') {
-                    this._ConnectionsByUrl.delete(key);
-                    this._ConnectionsById.delete(id);
-                    return connection;
-                }
-                entry = {
-                    status: 'ready',
-                    connection: connection.value,
-                    references: entry.references,
-                };
-                this._ConnectionsByUrl.set(key, entry);
-                this._ConnectionsById.set(id, entry);
-                return success(entry.connection);
-            }
-            else if (entry.status === 'init') {
-                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): Found a MainConnection but it is still in init state.');
-                // Wait for the connection to connect
-                entry.references += 1;
-                const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(), { once: true }));
-                const result = yield Promise.race([entry.promise, onAbort]);
-                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): MainConnection was in init state but is now resolved', result);
-                if (result === undefined)
-                    return failure('aborted');
-                return result;
-            }
-            else {
-                // Return the connection
-                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): Found a MainConnection and return it');
-                entry.references += 1;
-                return success(entry.connection);
-            }
-        });
-    }
-    releaseConnection(connection) {
-        logger.log(['Connection'], 'ConnectionPool.releaseConnection()');
-        const entry = this._ConnectionsById.get(connection.id);
-        logger.log(['Connection'], 'ConnectionPool.releaseConnection() entry refs', entry === null || entry === void 0 ? void 0 : entry.references);
-        if (entry === undefined)
-            return;
-        if (entry.status === 'init') {
-            logger.log(['Connection'], 'ConnectionPool.releaseConnection(): MainConnection state is init, return.');
-            return;
-        }
-        entry.references -= 1;
-        if (entry.references === 0) {
-            logger.log(['Connection'], 'ConnectionPool.releaseConnection(): References is 0, close the MainConnection.');
-            entry.connection.close();
-            this._ConnectionsByUrl.delete(create_connection_key(connection.transport, connection.address));
-            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();
-    }
-}
-function create_connection_key(transport, address) {
-    return `${transport} ${address}`;
-}

package/lib/plugin/deviceManager.d.ts

@@ -1,12 +0,0 @@
-import { MediaController, Device } from './mediaController';
-import { DeviceParameters } from './index';
-import { Backend, Result } from '@4players/odin-common';
-export declare function openCaptureDevice(controller: MediaController, parameters: DeviceParameters, apm: Backend.ApmConfig): Promise<Result<MediaStreamAudioSourceNode>>;
-export declare function stopMediaStream(ms: MediaStream): void;
-export declare function enumerateDevices(): Promise<Device[]>;
-/**
- * Requests audio and video browser permissions. Optionally, requests either audio or video permissions.
- * @private
- * @throws
- */
-export declare function requestMediaPermissions(): Promise<boolean>;

package/lib/plugin/deviceManager.js

@@ -1,120 +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 { Device } from './mediaController';
-import { logger } from './index';
-import { failure, sleep, success, } from '@4players/odin-common';
-let hasAudioPermissions = false;
-export function openCaptureDevice(controller, parameters, apm) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const deviceId = parameters.device
-            ? { exact: parameters.device.device.deviceId }
-            : undefined;
-        let stream;
-        try {
-            const result = yield Promise.race([
-                navigator.mediaDevices.getUserMedia({
-                    audio: {
-                        echoCancellation: apm.echoCanceller,
-                        noiseSuppression: apm.noiseSuppression !== 'None',
-                        autoGainControl: apm.gainController,
-                        // @ts-ignore chrome fix
-                        echoCancellationType: 'system',
-                        // sampleRate: 48000,
-                        deviceId,
-                    },
-                }),
-                sleep(30000, 'timeout'),
-            ]);
-            if (result === 'timeout')
-                return failure('getUserMedia; timeout');
-            hasAudioPermissions = true;
-            stream = result;
-        }
-        catch (reason) {
-            return failure(`getUserMedia; ${reason}`);
-        }
-        const sampleRate = stream.getAudioTracks()[0].getSettings().sampleRate;
-        const context = yield controller.audioContexts.acquire(sampleRate);
-        return success(context.createMediaStreamSource(stream));
-    });
-}
-export function stopMediaStream(ms) {
-    ms.getTracks().forEach((track) => {
-        track.stop();
-        ms.removeTrack(track);
-    });
-}
-export function enumerateDevices() {
-    return __awaiter(this, void 0, void 0, function* () {
-        hasAudioPermissions = yield requestMediaPermissions();
-        const mediaDeviceInfos = yield navigator.mediaDevices.enumerateDevices();
-        const devices = [];
-        let outputDeviceIndex = 0;
-        let inputDeviceIndex = 0;
-        for (const mediaDeviceInfo of mediaDeviceInfos) {
-            if (mediaDeviceInfo.kind === 'audioinput') {
-                if (inputDeviceIndex === 0) {
-                    devices.push(new Device(mediaDeviceInfo, true));
-                }
-                else {
-                    devices.push(new Device(mediaDeviceInfo, false));
-                }
-                inputDeviceIndex++;
-            }
-            if (mediaDeviceInfo.kind === 'audiooutput') {
-                if (outputDeviceIndex === 0) {
-                    devices.push(new Device(mediaDeviceInfo, true));
-                }
-                else {
-                    devices.push(new Device(mediaDeviceInfo, false));
-                }
-                outputDeviceIndex++;
-            }
-        }
-        return devices;
-    });
-}
-/**
- * Requests audio and video browser permissions. Optionally, requests either audio or video permissions.
- * @private
- * @throws
- */
-export function requestMediaPermissions() {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (hasAudioPermissions)
-            return true;
-        const constraints = {};
-        constraints.audio = {
-            sampleRate: undefined,
-            deviceId: '',
-            autoGainControl: false,
-            noiseSuppression: false,
-            advanced: undefined,
-            aspectRatio: undefined,
-            echoCancellation: false,
-            channelCount: 0,
-            facingMode: undefined,
-            frameRate: 0,
-        };
-        logger.debug(['Device'], 'requestMediaPermissions(): constraints', constraints);
-        try {
-            const ms = yield navigator.mediaDevices.getUserMedia(constraints);
-            ms === null || ms === void 0 ? void 0 : ms.getTracks().forEach((track) => {
-                track.stop();
-                ms.removeTrack(track);
-            });
-        }
-        catch (e) {
-            logger.error(['Device'], `requestMediaPermissions(): Requesting permissions for ${'audio'} failed.`, e);
-            return false;
-        }
-        return true;
-    });
-}

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

@@ -1,31 +0,0 @@
-import { ConnectionStatus, type DatagramHandler, type MainConnection } from '../mainConnection';
-import { MainCommands, MainNotifications, PeerId, Result } from '@4players/odin-common';
-import { Transport } from '..';
-import { Token } from '../token';
-import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
-export declare class H3MainConnection implements MainConnection {
-    readonly id: number;
-    readonly address: string;
-    readonly connection: WebTransport;
-    readonly rpc: TypedRpcConnection<MainCommands, MainNotifications>;
-    readonly closeController: AbortController;
-    status: ConnectionStatus;
-    readonly closePromise: Promise<'closed'>;
-    readonly datagramWriter: WritableStreamDefaultWriter<Uint8Array>;
-    get closeSignal(): AbortSignal;
-    get transport(): Transport;
-    get closed(): boolean;
-    static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
-    private constructor();
-    waitForConnected(): Promise<void>;
-    close(): void;
-    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<'closed' | Result<RpcConnection>>;
-    getReconnectToken(peerId: PeerId): Promise<Result<Token>>;
-    healthCheck(): Promise<boolean>;
-    sendDatagram(datagram: Uint8Array): void;
-    startLocalVideo(mediaId: number, track: MediaStreamTrack): void;
-    stopLocalVideo(mediaId: number): void;
-    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
-    stopRemoteVideo(mediaId: number): void;
-    private _Request;
-}