@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/peer/transport/ice.d.ts

@@ -0,0 +1,143 @@
+import { Event } from '../imports/common.js';
+import { Candidate, type IceConnection, type IceOptions } from '../../ice/index.js';
+import { type RTCStats } from '../media/stats.js';
+/**
+ *                                          +------------+
+                                            |            |
+                                            |disconnected|
+                                            |            |
+                                            +------------+
+                                            ^           ^
+                                            |           |
++------+      +----------+      +-----------+      +----------+
+|      |      |          |      |           |      |          |
+| new  | ---> | checking | ---> | connected | ---> | completed|
+|      |      |          |      |           |      |          |
++------+      +----+-----+      +-----------+      +----------+
+                    |
+                    |
+                    v
+                +-------+
+                |       |
+                | failed|
+                |       |
+                +-------+
+ */
+export declare class RTCIceTransport {
+    private iceGather;
+    readonly id: string;
+    connection: IceConnection;
+    state: RTCIceConnectionState;
+    readonly component = "rtp";
+    iceRestarts: number;
+    private checking?;
+    private renominating;
+    private readonly events;
+    onstatechange?: () => void;
+    ongatheringstatechange?: () => void;
+    readonly onStateChange: Event<["disconnected" | "connected" | "failed" | "closed" | "new" | "completed" | "checking"]>;
+    readonly onIceCandidate: Event<[IceCandidate | undefined]>;
+    readonly onNegotiationNeeded: Event<[]>;
+    constructor(iceGather: RTCIceGatherer);
+    addEventListener: (type: string, listener: (...args: any[]) => void, options?: boolean | {
+        once?: boolean;
+    }) => void;
+    removeEventListener: (type: string, listener: (...args: any[]) => void) => void;
+    dispatchEvent: (event: globalThis.Event) => boolean;
+    get role(): "unknown" | "controlling" | "controlled";
+    get gatheringState(): "new" | "complete" | "gathering";
+    get localCandidates(): IceCandidate[];
+    get localParameters(): RTCIceParameters;
+    getRemoteCandidates(): RTCIceCandidate[];
+    getLocalCandidates(): RTCIceCandidate[];
+    getSelectedCandidatePair(): {
+        local: RTCIceCandidate;
+        remote: RTCIceCandidate;
+    } | null;
+    getLocalParameters(): RTCIceParameters;
+    getRemoteParameters(): RTCIceParameters | null;
+    private setState;
+    gather(): Promise<void>;
+    setIceServers(options: Partial<IceOptions>): void;
+    addRemoteCandidate: (candidate?: IceCandidate) => Promise<void>;
+    setRemoteParams(remoteParameters: RTCIceParameters, renomination?: boolean): void;
+    restart(): void;
+    start(): Promise<void>;
+    /**
+     * Run the checks of the ICE session
+     */
+    private check;
+    stop(): Promise<void>;
+    getStats(timestamp?: number, transportId?: string): Promise<RTCStats[]>;
+}
+export declare const IceTransportStates: readonly ["new", "checking", "connected", "completed", "disconnected", "failed", "closed"];
+export type RTCIceConnectionState = (typeof IceTransportStates)[number];
+export declare const IceGathererStates: readonly ["new", "gathering", "complete"];
+export type IceGathererState = (typeof IceGathererStates)[number];
+export declare class RTCIceGatherer {
+    private options;
+    onIceCandidate: (candidate: IceCandidate | undefined) => void;
+    gatheringState: IceGathererState;
+    readonly connection: IceConnection;
+    readonly onGatheringStateChange: Event<["new" | "complete" | "gathering"]>;
+    constructor(options?: Partial<IceOptions>);
+    gather(): Promise<void>;
+    setIceServers(options: Partial<IceOptions>): void;
+    /**
+   * Set gathering state and notify listeners.
+   * ICE restart must use this instead of writing gatheringState directly so
+   * SecureTransportManager can refresh its aggregate iceGatheringState.
+   */
+    setGatheringState(state: IceGathererState): void;
+    get localCandidates(): IceCandidate[];
+    get localParameters(): RTCIceParameters;
+    private setState;
+}
+export declare function candidateFromIce(c: Candidate): IceCandidate;
+export declare function candidateToIce(x: IceCandidate): Candidate;
+export interface RTCIceCandidateInit {
+    candidate?: string;
+    sdpMLineIndex?: number | null;
+    sdpMid?: string | null;
+    usernameFragment?: string | null;
+}
+export declare class RTCIceCandidate {
+    candidate: string;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+    usernameFragment?: string;
+    constructor(props: Partial<RTCIceCandidate>);
+    static fromSdp(sdp: string): RTCIceCandidate;
+    static isThis(o: any): true | undefined;
+    toJSON(): {
+        candidate: string;
+        sdpMid: string | undefined;
+        sdpMLineIndex: number | undefined;
+        usernameFragment: string | undefined;
+    };
+}
+export declare class IceCandidate {
+    component: number;
+    foundation: string;
+    ip: string;
+    port: number;
+    priority: number;
+    protocol: string;
+    type: string;
+    generation?: number | undefined;
+    ufrag?: string | undefined;
+    relatedAddress?: string;
+    relatedPort?: number;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+    tcpType?: string;
+    constructor(component: number, foundation: string, ip: string, port: number, priority: number, protocol: string, type: string, generation?: number | undefined, ufrag?: string | undefined);
+    toJSON(): RTCIceCandidate;
+    static fromJSON(data: RTCIceCandidate | RTCIceCandidateInit): IceCandidate | undefined;
+}
+export declare class RTCIceParameters {
+    iceLite: boolean;
+    usernameFragment: string;
+    password: string;
+    constructor(props?: Partial<RTCIceParameters>);
+}

package/dist/cjs/lib/peer/transport/ice.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCIceParameters = exports.IceCandidate = exports.RTCIceCandidate = exports.RTCIceGatherer = exports.IceGathererStates = exports.IceTransportStates = exports.RTCIceTransport = void 0;
+exports.candidateFromIce = candidateFromIce;
+exports.candidateToIce = candidateToIce;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("../imports/common.js");
+const index_js_1 = require("../../ice/index.js");
+const helper_js_1 = require("../helper.js");
+const stats_js_1 = require("../media/stats.js");
+const sdp_js_1 = require("../sdp.js");
+const log = (0, common_js_1.debug)('webrtc/peer/transport/ice');
+function mapCandidatePairState(state) {
+    switch (state) {
+        case 0:
+            return 'frozen';
+        case 1:
+            return 'waiting';
+        case 2:
+            return 'in-progress';
+        case 3:
+            return 'succeeded';
+        case 4:
+            return 'failed';
+        default:
+            return 'failed';
+    }
+}
+/**
+ *                                          +------------+
+                                            |            |
+                                            |disconnected|
+                                            |            |
+                                            +------------+
+                                            ^           ^
+                                            |           |
++------+      +----------+      +-----------+      +----------+
+|      |      |          |      |           |      |          |
+| new  | ---> | checking | ---> | connected | ---> | completed|
+|      |      |          |      |           |      |          |
++------+      +----+-----+      +-----------+      +----------+
+                    |
+                    |
+                    v
+                +-------+
+                |       |
+                | failed|
+                |       |
+                +-------+
+ */
+class RTCIceTransport {
+    constructor(iceGather) {
+        this.iceGather = iceGather;
+        this.id = (0, node_crypto_1.randomUUID)().toString();
+        this.state = 'new';
+        this.component = 'rtp';
+        this.iceRestarts = 0;
+        this.renominating = false;
+        this.events = new helper_js_1.EventTarget();
+        this.onStateChange = new common_js_1.Event();
+        this.onIceCandidate = new common_js_1.Event();
+        this.onNegotiationNeeded = new common_js_1.Event();
+        this.addEventListener = (type, listener, options) => {
+            this.events.addEventListener(type, listener, options);
+        };
+        this.removeEventListener = (type, listener) => {
+            this.events.removeEventListener(type, listener);
+        };
+        this.dispatchEvent = (event) => this.events.dispatchEvent(event);
+        this.addRemoteCandidate = async (candidate) => {
+            if (!this.connection.remoteCandidatesEnd) {
+                await this.connection.addRemoteCandidate(candidate ? candidateToIce(candidate) : undefined);
+            }
+        };
+        this.connection = this.iceGather.connection;
+        this.connection.stateChanged.subscribe((state) => {
+            this.setState(state);
+        });
+        this.iceGather.onIceCandidate = (candidate) => {
+            this.onIceCandidate.execute(candidate);
+        };
+        this.iceGather.onGatheringStateChange.subscribe(() => {
+            this.ongatheringstatechange?.();
+            this.events.emit('gatheringstatechange');
+        });
+    }
+    get role() {
+        if (!this.connection.remoteUsername || !this.connection.remotePassword) {
+            return 'unknown';
+        }
+        if (this.connection.iceControlling)
+            return 'controlling';
+        else
+            return 'controlled';
+    }
+    get gatheringState() {
+        return this.iceGather.gatheringState;
+    }
+    get localCandidates() {
+        return this.iceGather.localCandidates;
+    }
+    get localParameters() {
+        return this.iceGather.localParameters;
+    }
+    getRemoteCandidates() {
+        return this.connection.remoteCandidates
+            .filter((candidate) => candidate.type !== 'prflx')
+            .map((candidate) => candidateFromIce(candidate).toJSON());
+    }
+    getLocalCandidates() {
+        return this.connection.localCandidates.map((candidate) => candidateFromIce(candidate).toJSON());
+    }
+    getSelectedCandidatePair() {
+        const pair = this.connection.candidatePairs.find((candidate) => candidate.nominated) ??
+            this.connection.candidatePairs.find((candidate) => candidate.state === 3);
+        if (!pair) {
+            return null;
+        }
+        return {
+            local: candidateFromIce(pair.localCandidate).toJSON(),
+            remote: candidateFromIce(pair.remoteCandidate).toJSON()
+        };
+    }
+    getLocalParameters() {
+        return this.localParameters ?? null;
+    }
+    getRemoteParameters() {
+        if (!this.connection.remoteUsername || !this.connection.remotePassword) {
+            return null;
+        }
+        return new RTCIceParameters({
+            iceLite: this.connection.remoteIsLite,
+            password: this.connection.remotePassword,
+            usernameFragment: this.connection.remoteUsername
+        });
+    }
+    setState(state, emitEvent = true) {
+        if (state !== this.state) {
+            this.state = state;
+            this.onStateChange.execute(state);
+            if (emitEvent) {
+                this.onstatechange?.();
+                this.events.emit('statechange');
+            }
+        }
+    }
+    gather() {
+        return this.iceGather.gather();
+    }
+    setIceServers(options) {
+        this.iceGather.setIceServers(options);
+    }
+    setRemoteParams(remoteParameters, renomination = false) {
+        if (renomination) {
+            this.renominating = true;
+        }
+        if (this.connection.remoteUsername &&
+            this.connection.remotePassword &&
+            (this.connection.remoteUsername !== remoteParameters.usernameFragment ||
+                this.connection.remotePassword !== remoteParameters.password)) {
+            if (this.renominating) {
+                log('renomination', remoteParameters);
+                this.connection.resetNominatedPair();
+                this.checking = undefined;
+                this.renominating = false;
+            }
+            else {
+                log('restart', remoteParameters);
+                this.restart();
+            }
+        }
+        this.connection.setRemoteParams(remoteParameters);
+    }
+    restart() {
+        this.iceRestarts++;
+        this.connection.restart().catch((error) => log('restart failed', error));
+        this.setState('new');
+        // Use setGatheringState so onGatheringStateChange fires and the
+        // SecureTransportManager aggregate iceGatheringState stays in sync.
+        this.iceGather.setGatheringState('new');
+        this.checking = undefined;
+        this.onNegotiationNeeded.execute();
+    }
+    async start() {
+        if (this.state === 'closed') {
+            throw new Error('RTCIceTransport is closed');
+        }
+        if (!this.connection.remotePassword || !this.connection.remoteUsername) {
+            throw new Error('remoteParams missing');
+        }
+        this.checking ??= this.check();
+        await this.checking;
+    }
+    /**
+     * Run the checks of the ICE session
+     */
+    async check() {
+        this.setState('checking');
+        try {
+            await this.connection.connect();
+        }
+        catch (error) {
+            //Closed meanwhile (the state checked at the start may have changed): it stays closed
+            if (this.state !== 'closed')
+                this.setState('failed');
+            throw error;
+        }
+    }
+    async stop() {
+        if (this.state !== 'closed') {
+            this.setState('closed', false);
+            await this.connection.close();
+        }
+        this.onStateChange.complete();
+        this.onIceCandidate.complete();
+        this.onNegotiationNeeded.complete();
+    }
+    async getStats(timestamp = (0, stats_js_1.getStatsTimestamp)(), transportId = (0, stats_js_1.generateStatsId)('transport', this.id)) {
+        const stats = [];
+        // Local candidates
+        for (const candidate of this.connection.localCandidates) {
+            const candidateStats = {
+                type: 'local-candidate',
+                id: (0, stats_js_1.generateStatsId)('local-candidate', candidate.id),
+                timestamp,
+                transportId,
+                address: candidate.host,
+                port: candidate.port,
+                protocol: candidate.transport,
+                candidateType: candidate.type,
+                priority: candidate.priority,
+                foundation: candidate.foundation,
+                relatedAddress: candidate.relatedAddress,
+                relatedPort: candidate.relatedPort,
+                usernameFragment: candidate.ufrag,
+                tcpType: candidate.tcptype
+            };
+            stats.push(candidateStats);
+        }
+        // Remote candidates
+        for (const candidate of this.connection.remoteCandidates) {
+            const candidateStats = {
+                type: 'remote-candidate',
+                id: (0, stats_js_1.generateStatsId)('remote-candidate', candidate.id),
+                timestamp,
+                transportId,
+                address: candidate.host,
+                port: candidate.port,
+                protocol: candidate.transport,
+                candidateType: candidate.type,
+                priority: candidate.priority,
+                foundation: candidate.foundation,
+                relatedAddress: candidate.relatedAddress,
+                relatedPort: candidate.relatedPort,
+                usernameFragment: candidate.ufrag,
+                tcpType: candidate.tcptype
+            };
+            stats.push(candidateStats);
+        }
+        // Candidate pairs
+        const pairs = this.connection?.candidatePairs
+            ? [
+                ...this.connection.candidatePairs.filter((p) => p.nominated),
+                ...this.connection.candidatePairs.filter((p) => !p.nominated)
+            ]
+            : [];
+        for (const pair of pairs) {
+            const pairStats = {
+                type: 'candidate-pair',
+                id: (0, stats_js_1.generateStatsId)('candidate-pair', pair.id),
+                timestamp,
+                transportId,
+                localCandidateId: (0, stats_js_1.generateStatsId)('local-candidate', pair.localCandidate.id),
+                remoteCandidateId: (0, stats_js_1.generateStatsId)('remote-candidate', pair.remoteCandidate.id),
+                state: mapCandidatePairState(pair.state),
+                nominated: pair.nominated,
+                packetsSent: pair.packetsSent,
+                packetsReceived: pair.packetsReceived,
+                bytesSent: pair.bytesSent,
+                bytesReceived: pair.bytesReceived,
+                currentRoundTripTime: pair.rtt,
+                totalRoundTripTime: pair.totalRoundTripTime,
+                roundTripTimeMeasurements: pair.roundTripTimeMeasurements,
+                requestsReceived: pair.requestsReceived,
+                requestsSent: pair.requestsSent,
+                responsesReceived: pair.responsesReceived,
+                responsesSent: pair.responsesSent,
+                retransmissionsReceived: pair.retransmissionsReceived,
+                retransmissionsSent: pair.retransmissionsSent,
+                consentRequestsSent: pair.consentRequestsSent
+            };
+            stats.push(pairStats);
+        }
+        return stats;
+    }
+}
+exports.RTCIceTransport = RTCIceTransport;
+exports.IceTransportStates = [
+    'new',
+    'checking',
+    'connected',
+    'completed',
+    'disconnected',
+    'failed',
+    'closed'
+];
+exports.IceGathererStates = ['new', 'gathering', 'complete'];
+class RTCIceGatherer {
+    constructor(options = {}) {
+        this.options = options;
+        this.onIceCandidate = () => { };
+        this.gatheringState = 'new';
+        this.onGatheringStateChange = new common_js_1.Event();
+        this.connection = new index_js_1.Connection(false, this.options);
+        this.connection.onIceCandidate.subscribe((candidate) => {
+            this.onIceCandidate(candidateFromIce(candidate));
+        });
+    }
+    async gather() {
+        if (this.gatheringState === 'new') {
+            this.setState('gathering');
+            await this.connection.gatherCandidates();
+            this.onIceCandidate(undefined);
+            this.setState('complete');
+        }
+    }
+    setIceServers(options) {
+        this.connection.setIceServers(options);
+    }
+    /**
+   * Set gathering state and notify listeners.
+   * ICE restart must use this instead of writing gatheringState directly so
+   * SecureTransportManager can refresh its aggregate iceGatheringState.
+   */
+    setGatheringState(state) {
+        this.setState(state);
+    }
+    get localCandidates() {
+        return this.connection.localCandidates.map(candidateFromIce);
+    }
+    get localParameters() {
+        const params = new RTCIceParameters({
+            iceLite: this.connection.iceLite,
+            usernameFragment: this.connection.localUsername,
+            password: this.connection.localPassword
+        });
+        return params;
+    }
+    setState(state) {
+        if (state !== this.gatheringState) {
+            this.gatheringState = state;
+            this.onGatheringStateChange.execute(state);
+        }
+    }
+}
+exports.RTCIceGatherer = RTCIceGatherer;
+function candidateFromIce(c) {
+    const candidate = new IceCandidate(c.component, c.foundation, c.host, c.port, c.priority, c.transport, c.type, c.generation, c.ufrag);
+    candidate.relatedAddress = c.relatedAddress;
+    candidate.relatedPort = c.relatedPort;
+    candidate.tcpType = c.tcptype;
+    return candidate;
+}
+function candidateToIce(x) {
+    return new index_js_1.Candidate(x.foundation, x.component, x.protocol, x.priority, x.ip, x.port, x.type, x.relatedAddress, x.relatedPort, x.tcpType, x.generation, x.ufrag);
+}
+class RTCIceCandidate {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+    static fromSdp(sdp) {
+        const ice = index_js_1.Candidate.fromSdp(sdp);
+        const candidate = candidateFromIce(ice);
+        return candidate.toJSON();
+    }
+    static isThis(o) {
+        if (typeof o?.candidate === 'string')
+            return true;
+    }
+    toJSON() {
+        return {
+            candidate: this.candidate,
+            sdpMid: this.sdpMid,
+            sdpMLineIndex: this.sdpMLineIndex,
+            usernameFragment: this.usernameFragment
+        };
+    }
+}
+exports.RTCIceCandidate = RTCIceCandidate;
+class IceCandidate {
+    constructor(component, foundation, ip, port, priority, protocol, type, generation, ufrag) {
+        this.component = component;
+        this.foundation = foundation;
+        this.ip = ip;
+        this.port = port;
+        this.priority = priority;
+        this.protocol = protocol;
+        this.type = type;
+        this.generation = generation;
+        this.ufrag = ufrag;
+    }
+    toJSON() {
+        return new RTCIceCandidate({
+            candidate: (0, sdp_js_1.candidateToSdp)(this),
+            sdpMLineIndex: this.sdpMLineIndex,
+            sdpMid: this.sdpMid,
+            usernameFragment: this.ufrag
+        });
+    }
+    static fromJSON(data) {
+        try {
+            if (!data.candidate) {
+                throw new Error('candidate is required');
+            }
+            const normalizedCandidate = data.candidate.startsWith('candidate:')
+                ? data.candidate.slice('candidate:'.length)
+                : data.candidate;
+            const candidate = (0, sdp_js_1.candidateFromSdp)(normalizedCandidate);
+            candidate.sdpMLineIndex = data.sdpMLineIndex ?? undefined;
+            candidate.sdpMid = data.sdpMid ?? undefined;
+            return candidate;
+        }
+        catch (error) {
+            //A candidate that cannot be parsed is skipped
+            log('candidate not parsed', error);
+        }
+    }
+}
+exports.IceCandidate = IceCandidate;
+class RTCIceParameters {
+    constructor(props = {}) {
+        this.iceLite = false;
+        Object.assign(this, props);
+    }
+}
+exports.RTCIceParameters = RTCIceParameters;

package/dist/cjs/lib/peer/transport/sctp.d.ts

@@ -0,0 +1,56 @@
+import { Event } from '../imports/common.js';
+import { SCTP, type SCTPOptions } from '../../sctp/index.js';
+import { RTCDataChannel } from '../dataChannel.js';
+import type { RTCDtlsTransport } from './dtls.js';
+export declare const DEFAULT_MAX_MESSAGE_SIZE = 65536;
+export declare class RTCSctpTransport {
+    port: number;
+    maxMessageSize: number;
+    private readonly sctpOptions;
+    dtlsTransport: RTCDtlsTransport;
+    sctp: SCTP;
+    readonly onDataChannel: Event<[RTCDataChannel]>;
+    readonly id: string;
+    mid?: string;
+    mLineIndex?: number;
+    bundled: boolean;
+    dataChannels: {
+        [key: number]: RTCDataChannel;
+    };
+    remoteMaxMessageSize: number;
+    private dataChannelQueue;
+    private dataChannelId?;
+    private eventDisposer;
+    constructor(port?: number, maxMessageSize?: number, sctpOptions?: SCTPOptions);
+    get transport(): RTCDtlsTransport;
+    setDtlsTransport(dtlsTransport: RTCDtlsTransport): void;
+    /**
+     * Keep bytes received out of the receive window while the application holds them (see SCTP.holdReceived)
+     * @param bytes
+     */
+    holdReceived(bytes: number): void;
+    /**
+     * Give back bytes held to the receive window (see SCTP.releaseReceived)
+     * @param bytes
+     */
+    releaseReceived(bytes: number): void;
+    private get isServer();
+    channelByLabel(label: string): RTCDataChannel | undefined;
+    private datachannelReceive;
+    dataChannelAddNegotiated(channel: RTCDataChannel): void;
+    dataChannelOpen(channel: RTCDataChannel): void;
+    private dataChannelFlush;
+    private assertSendableMessageSize;
+    datachannelSend: (channel: RTCDataChannel, data: Buffer | string) => number;
+    getCapabilities(): RTCSctpCapabilities;
+    static getCapabilities(maxMessageSize?: number): RTCSctpCapabilities;
+    setRemoteMaxMessageSize(maxMessageSize?: number): void;
+    setRemotePort(port: number): void;
+    start(remotePort: number): Promise<void>;
+    stop(): Promise<void>;
+    dataChannelClose(channel: RTCDataChannel): void;
+}
+export declare class RTCSctpCapabilities {
+    maxMessageSize: number;
+    constructor(maxMessageSize: number);
+}