@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/peer/sctpManager.d.ts

@@ -0,0 +1,28 @@
+import type { SCTPOptions } from '../sctp/index.js';
+import { Event } from './imports/common.js';
+import { RTCDataChannel } from './dataChannel.js';
+import { type RTCStats } from './media/stats.js';
+import type { MediaDescription } from './sdp.js';
+import { RTCSctpTransport } from './transport/sctp.js';
+export declare class SctpTransportManager {
+    sctpTransport?: RTCSctpTransport;
+    sctpRemotePort?: number;
+    dataChannelsOpened: number;
+    dataChannelsClosed: number;
+    private dataChannels;
+    readonly onDataChannel: Event<[RTCDataChannel]>;
+    constructor();
+    createSctpTransport(maxMessageSize?: number, sctpOptions?: SCTPOptions): RTCSctpTransport;
+    createDataChannel(label: string, options?: Partial<{
+        maxPacketLifeTime?: number;
+        protocol: string;
+        maxRetransmits?: number;
+        ordered: boolean;
+        negotiated: boolean;
+        id?: number;
+    }>): RTCDataChannel;
+    connectSctp(): Promise<void>;
+    setRemoteSCTP(remoteMedia: MediaDescription, mLineIndex: number): void;
+    close(): Promise<void>;
+    getStats(timestamp?: number): Promise<RTCStats[]>;
+}

package/dist/cjs/lib/peer/sctpManager.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SctpTransportManager = void 0;
+const errors_js_1 = require("./errors.js");
+const common_js_1 = require("./imports/common.js");
+const dataChannel_js_1 = require("./dataChannel.js");
+const stats_js_1 = require("./media/stats.js");
+const sctp_js_1 = require("./transport/sctp.js");
+const log = (0, common_js_1.debug)('webrtc/peer/sctpManager');
+class SctpTransportManager {
+    constructor() {
+        this.dataChannelsOpened = 0;
+        this.dataChannelsClosed = 0;
+        this.dataChannels = [];
+        this.onDataChannel = new common_js_1.Event();
+    }
+    createSctpTransport(maxMessageSize, sctpOptions) {
+        const sctp = new sctp_js_1.RTCSctpTransport(5000, maxMessageSize, sctpOptions);
+        sctp.mid = undefined;
+        sctp.onDataChannel.subscribe((channel) => {
+            this.dataChannelsOpened++;
+            this.dataChannels.push(channel);
+            this.onDataChannel.execute(channel);
+        });
+        this.sctpTransport = sctp;
+        return sctp;
+    }
+    createDataChannel(label, options = {}) {
+        const maxPacketLifeTime = coerceUnsignedShortOption(options.maxPacketLifeTime, 'maxPacketLifeTime');
+        const maxRetransmits = coerceUnsignedShortOption(options.maxRetransmits, 'maxRetransmits');
+        const base = {
+            protocol: '',
+            ordered: true,
+            negotiated: false
+        };
+        const settings = {
+            ...base,
+            ...options,
+            maxPacketLifeTime,
+            maxRetransmits
+        };
+        if (settings.maxPacketLifeTime != null && settings.maxRetransmits != null) {
+            throw (0, errors_js_1.createWebRtcTypeError)('maxPacketLifeTime and maxRetransmits cannot both be set');
+        }
+        if (!this.sctpTransport) {
+            this.sctpTransport = this.createSctpTransport();
+        }
+        const parameters = new dataChannel_js_1.RTCDataChannelParameters({
+            id: settings.id,
+            label,
+            maxPacketLifeTime: settings.maxPacketLifeTime,
+            maxRetransmits: settings.maxRetransmits,
+            negotiated: settings.negotiated,
+            ordered: settings.ordered,
+            protocol: settings.protocol
+        });
+        const channel = new dataChannel_js_1.RTCDataChannel(this.sctpTransport, parameters);
+        this.dataChannelsOpened++;
+        this.dataChannels.push(channel);
+        channel.stateChange.subscribe((state) => {
+            if (state === 'closed') {
+                this.dataChannelsClosed++;
+                const index = this.dataChannels.indexOf(channel);
+                if (index !== -1) {
+                    this.dataChannels.splice(index, 1);
+                }
+            }
+        });
+        return channel;
+    }
+    async connectSctp() {
+        if (!this.sctpTransport || !this.sctpRemotePort) {
+            return;
+        }
+        await this.sctpTransport.start(this.sctpRemotePort);
+        await this.sctpTransport.sctp.stateChanged.connected.asPromise();
+        log('sctp connected');
+    }
+    setRemoteSCTP(remoteMedia, mLineIndex) {
+        if (!this.sctpTransport) {
+            return;
+        }
+        // # configure sctp
+        this.sctpTransport.setRemoteMaxMessageSize(remoteMedia.sctpCapabilities?.maxMessageSize);
+        this.sctpRemotePort = remoteMedia.sctpPort;
+        if (!this.sctpRemotePort) {
+            throw new Error('sctpRemotePort not exist');
+        }
+        this.sctpTransport.setRemotePort(this.sctpRemotePort);
+        this.sctpTransport.mLineIndex = mLineIndex;
+        if (!this.sctpTransport.mid) {
+            this.sctpTransport.mid = remoteMedia.rtp.muxId;
+        }
+    }
+    async close() {
+        if (this.sctpTransport) {
+            await this.sctpTransport.stop();
+            // UdpTransport.send は既知アドレスでは callback を待たない。呼び出し側が
+            // 直後に ICE ソケットを閉じると queued な AbortChunk が落ちるので、1 tick 譲る。
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        this.onDataChannel.allUnsubscribe();
+    }
+    async getStats(timestamp = (0, stats_js_1.getStatsTimestamp)()) {
+        const stats = [];
+        for (const channel of this.dataChannels) {
+            const channelStats = {
+                type: 'data-channel',
+                id: (0, stats_js_1.generateStatsId)('data-channel', channel.id ?? channel.statsId),
+                timestamp,
+                label: channel.label,
+                protocol: channel.protocol,
+                dataChannelIdentifier: channel.id ?? undefined,
+                state: channel.readyState,
+                messagesSent: channel.messagesSent || 0,
+                bytesSent: channel.bytesSent || 0,
+                messagesReceived: channel.messagesReceived || 0,
+                bytesReceived: channel.bytesReceived || 0
+            };
+            stats.push(channelStats);
+        }
+        return stats;
+    }
+}
+exports.SctpTransportManager = SctpTransportManager;
+function coerceUnsignedShortOption(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const coerced = Number(value);
+    if (!Number.isFinite(coerced) ||
+        !Number.isInteger(coerced) ||
+        coerced < 0 ||
+        coerced > 65535) {
+        throw (0, errors_js_1.createWebRtcTypeError)(`${name} must be an unsigned short`);
+    }
+    return coerced;
+}

package/dist/cjs/lib/peer/sdp.d.ts

@@ -0,0 +1,97 @@
+import { type RTCRtpParameters, RTCRtpSimulcastParameters } from './media/parameters.js';
+import type { MediaDirection } from './media/rtpTransceiver.js';
+import { type DtlsRole, RTCDtlsFingerprint, RTCDtlsParameters } from './transport/dtls.js';
+import { type IceCandidate, RTCIceParameters } from './transport/ice.js';
+import { RTCSctpCapabilities } from './transport/sctp.js';
+import type { Kind } from './types/domain.js';
+export declare class SessionDescription {
+    version: number;
+    origin?: string;
+    name: string;
+    time: string;
+    host?: string;
+    group: GroupDescription[];
+    extMapAllowMixed: boolean;
+    msidSemantic: GroupDescription[];
+    media: MediaDescription[];
+    type: 'offer' | 'answer' | 'pranswer';
+    dtlsRole: DtlsRole;
+    iceOptions: string;
+    iceLite: boolean;
+    icePassword: string;
+    iceUsernameFragment: string;
+    dtlsFingerprints: RTCDtlsFingerprint[];
+    private cachedJson?;
+    static parse(sdp: string): SessionDescription;
+    webrtcTrackId(media: MediaDescription): string | undefined;
+    get string(): string;
+    toJSON(): RTCSessionDescription;
+    toSdp(): {
+        type: "offer" | "answer" | "pranswer";
+        sdp: string;
+    };
+}
+export declare class MediaDescription {
+    kind: Kind;
+    port: number;
+    profile: string;
+    fmt: string[] | number[];
+    host?: string;
+    direction?: MediaDirection;
+    msids: string[];
+    rtcpPort?: number;
+    rtcpHost?: string;
+    rtcpMux: boolean;
+    bundleOnly: boolean;
+    ssrc: SsrcDescription[];
+    ssrcGroup: GroupDescription[];
+    rtp: RTCRtpParameters;
+    sctpCapabilities?: RTCSctpCapabilities;
+    sctpMap: {
+        [key: number]: string;
+    };
+    sctpPort?: number;
+    dtlsParams?: RTCDtlsParameters;
+    iceParams?: RTCIceParameters;
+    iceCandidates: IceCandidate[];
+    iceCandidatesComplete: boolean;
+    iceOptions?: string;
+    simulcastParameters: RTCRtpSimulcastParameters[];
+    constructor(kind: Kind, port: number, profile: string, fmt: string[] | number[]);
+    get msid(): string | undefined;
+    set msid(value: string | undefined);
+    toString(): string;
+}
+export declare class GroupDescription {
+    semantic: string;
+    items: string[];
+    constructor(semantic: string, items: string[]);
+    get str(): string;
+}
+export declare function candidateToSdp(c: IceCandidate): string;
+export declare function parseGroup(dest: GroupDescription[], value: string, type?: (v: string) => any): void;
+export declare function candidateFromSdp(sdp: string): IceCandidate;
+export declare class RTCSessionDescription {
+    readonly sdp: string;
+    readonly type: 'offer' | 'answer' | 'pranswer';
+    constructor(sdp: string, type: 'offer' | 'answer' | 'pranswer');
+    static isThis(o: any): true | undefined;
+    toSdp(): {
+        sdp: string;
+        type: "offer" | "answer" | "pranswer";
+    };
+}
+export declare function addSDPHeader(type: 'offer' | 'answer', description: SessionDescription): void;
+export declare function codecParametersFromString(str: string): any;
+export declare function codecParametersToString(parameters: {
+    [key: string]: string | number | undefined;
+}, joint?: string): string | undefined;
+export declare class SsrcDescription {
+    ssrc: number;
+    cname?: string;
+    msid?: string;
+    msLabel?: string;
+    label?: string;
+    constructor(props: Partial<SsrcDescription>);
+}
+export type BundlePolicy = 'max-compat' | 'max-bundle' | 'disable';