@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/shared/Room.js

@@ -0,0 +1,515 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = void 0;
+const SignalingProtocol_js_1 = require("../protocol/SignalingProtocol.js");
+const Emitter_js_1 = require("./Emitter.js");
+const Peer_js_1 = require("./Peer.js");
+/**
+ * The tracks and the channels kept at most while their member is not known
+ */
+const MAX_UNROUTED = 256;
+/**
+ * A room joined through the signaling: its {@link Peer}s, one for each other member. Listen to `peer` to use each of
+ * them (create its data channels, listen to its channels and its tracks), to `peer-left` for the ones closed; publish
+ * the tracks sent to every member with `publish()`.
+ *
+ * The members are connected peer to peer, or, in a room with a media server (its `sfu`), each member to the server
+ * only: the server forwards the tracks published to the other members, and the room and its peers work as without it.
+ */
+class Room extends Emitter_js_1.Emitter {
+    #host;
+    #peers = new Map();
+    //The peers whose connection is created, given to the listeners of peer
+    #ready = new Set();
+    //The tracks published, and the transceivers of the room sending them (reused for the next ones)
+    #published = new Map();
+    #transceivers = new WeakSet();
+    //With a media server: the streams it sends, by their id on the connection to it
+    #streams = new Map();
+    //The tracks and the channels received through the media server not given to their peer yet (its member or its
+    //stream unknown yet), MAX_UNROUTED of each at most
+    #unrouted = [];
+    #unroutedChannels = [];
+    //The messages to the media server waiting for its control channel
+    #controls = [];
+    #metadata;
+    #left = false;
+    //The id of the media server of the room, and the peer of its connection
+    #sfu;
+    #server;
+    #control;
+    //The media server each member is connected to, as the signaling gives it
+    #serversOf = new WeakMap();
+    /**
+     * Create a room (by the signaling session joining it).
+     * @param host The session.
+     * @param name The room.
+     * @param metadata The metadata the local member joined with.
+     */
+    constructor(host, name, metadata) {
+        super();
+        this.#host = host;
+        this.name = name;
+        this.#metadata = metadata;
+    }
+    /**
+     * The peers whose connection is created.
+     */
+    get peers() {
+        return [...this.#ready];
+    }
+    /**
+     * The metadata the local member joined with.
+     */
+    get metadata() {
+        return this.#metadata;
+    }
+    /**
+     * Whether the room was left.
+     */
+    get left() {
+        return this.#left;
+    }
+    /**
+     * The id of the media server of the room, when it has one: the members are connected to it, not to each other.
+     */
+    get sfu() {
+        return this.#sfu;
+    }
+    /**
+     * The peer of a member.
+     * @param id The member's id.
+     * @returns The peer, or undefined when the member is not in the room or its connection is not created yet.
+     */
+    peer(id) {
+        const peer = this.#peers.get(id);
+        return peer && this.#ready.has(peer) ? peer : undefined;
+    }
+    /**
+     * A stream received through the media server of the room: the member sending it, and its id on the connection of
+     * that member (`event.streams` of a track carries the ids of the connection to the server).
+     * @param id The id of the stream on the connection to the server.
+     * @returns The stream, or undefined when the room has no media server or the stream is not known.
+     */
+    streamOf(id) {
+        return this.#streams.get(id);
+    }
+    /**
+     * Send a track to every member of the room, those joining later too: on each connection, or once to the media
+     * server of the room. A track published after `unpublish()` takes the transceiver of a track unpublished.
+     * @param track The track: a `MediaStreamTrack` in the browsers, a `MediaTrack` in Node.js.
+     * @param streams Its streams (a `MediaStream` in the browsers, its id in Node.js): the members group the tracks of
+     * a stream (to play the audio and the video together).
+     * @returns Resolves once the track is added to the connections.
+     */
+    async publish(track, ...streams) {
+        if (this.#left || this.#published.has(track))
+            return;
+        const publication = { streams: streams, transceivers: new Map() };
+        this.#published.set(track, publication);
+        const targets = this.#sfu ? [this.#serverPeer()] : [...this.#peers.values()];
+        await Promise.all(targets.map((peer) => this.#send(peer, track)));
+    }
+    /**
+     * Stop sending a track published: its transceivers stay, inactive, for the next track published.
+     * @param track The track.
+     * @returns Resolves once the track is taken out of the connections.
+     */
+    async unpublish(track) {
+        const publication = this.#published.get(track);
+        if (!publication)
+            return;
+        this.#published.delete(track);
+        await Promise.all([...publication.transceivers.values()].map(async (transceiver) => {
+            try {
+                transceiver.direction = 'inactive';
+                await transceiver.sender.replaceTrack(null);
+            }
+            catch {
+                //Its connection is closed
+            }
+        }));
+    }
+    /**
+     * Add a listener of an event; a listener of `peer` is called at once for the peers already there.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns This room.
+     */
+    on(event, listener) {
+        super.on(event, listener);
+        if (event === 'peer')
+            for (const peer of [...this.#ready])
+                listener(peer);
+        return this;
+    }
+    /**
+     * Leave the room: its peers are closed.
+     * @returns Resolves once the server is told.
+     */
+    async leave() {
+        if (this.#left)
+            return;
+        this.#left = true;
+        for (const peer of [...this.#peers.values()])
+            peer.close();
+        this.#server?.close();
+        this.emit('close');
+        await this.#host.leave(this);
+    }
+    /**
+     * The members in the room when it was joined, or joined again after a reconnection of the signaling: the peers of
+     * the members not there any more are dropped (unless their connection is up), the new members get a peer
+     * @param peers
+     * @param metadata
+     * @param sfu The media server of the room, when it has one.
+     * @internal
+     */
+    members(peers, metadata, sfu) {
+        this.#metadata = metadata;
+        //Another media server: the connection to the one before is of no use
+        if (this.#server && this.#server.id !== sfu)
+            this.#serverGone();
+        this.#sfu = sfu;
+        const present = new Set(peers.map((peer) => peer.peerId));
+        if (this.#server && !this.#server.closed && !present.has(this.#server.id))
+            this.#server.left();
+        for (const peer of [...this.#peers.values()]) {
+            if (!present.has(peer.id))
+                peer.left();
+        }
+        //The media server first: the other peers use its connection
+        const ordered = [...peers].sort((a, b) => Number(b.peerId === sfu) - Number(a.peerId === sfu));
+        for (const member of ordered)
+            this.joined({ room: this.name, ...member });
+        for (const peer of this.#peers.values())
+            peer.signalingUp();
+        this.#server?.signalingUp();
+    }
+    /**
+     * A member joined (or joined again)
+     * @param event
+     * @internal
+     */
+    joined(event) {
+        if (this.#left || event.peerId === this.#host.localId)
+            return;
+        if (event.role === 'sfu') {
+            //The media server of the room; the one of another node is not connected to
+            if (event.peerId !== this.#sfu)
+                return;
+            const server = this.#server;
+            if (server && !server.closed && server.id === event.peerId && (server.session === event.session || event.session === undefined))
+                return server.rejoined(event.metadata);
+            //Another one, or the same one joining again with a new session: the peers of the members are replaced
+            server?.close();
+            this.#serverPeer(event.metadata, event.session);
+            return;
+        }
+        const peer = this.#peers.get(event.peerId);
+        const moved = !!peer && event.sfu !== undefined && this.#serversOf.has(peer) && this.#serversOf.get(peer) !== event.sfu;
+        if (peer && !peer.closed && (peer.session === event.session || event.session === undefined) && !moved) {
+            peer.rejoined(event.metadata);
+            return;
+        }
+        //A new client behind the same id (a reloaded page), or the member connected to another media server (its node
+        //went down): its old connection, or the channels through its media server, are of no use
+        peer?.close();
+        this.#add(event.peerId, event.metadata, event.session, event.sfu);
+    }
+    /**
+     * A member left
+     * @param event
+     * @internal
+     */
+    departed(event) {
+        if (this.#left)
+            return;
+        if (this.#server && !this.#server.closed && event.peerId === this.#server.id) {
+            //The media server went away (its node is down): the room is joined again, for another one
+            this.#serverGone();
+            this.#host.rejoin(this);
+            return;
+        }
+        const peer = this.#peers.get(event.peerId);
+        if (!peer)
+            return;
+        if (event.reason === 'left') {
+            peer.close();
+        }
+        else {
+            peer.left();
+        }
+    }
+    /**
+     * A signal from a member
+     * @param event
+     * @internal
+     */
+    signal(event) {
+        if (this.#left)
+            return;
+        const signal = {};
+        if (event.description)
+            signal.description = event.description;
+        if (event.candidate)
+            signal.candidate = event.candidate;
+        if (this.#sfu) {
+            //Through the media server only; its streams are known before its description fires the track events
+            if (event.from !== this.#sfu)
+                return;
+            for (const stream of event.streams ?? [])
+                this.#streams.set(stream.id, stream);
+            let server = this.#serverPeer();
+            if (event.session !== undefined && server.session !== undefined && server.session !== event.session) {
+                server.close();
+                server = this.#serverPeer(undefined, event.session);
+            }
+            server.receive(signal);
+            this.#route();
+            return;
+        }
+        let peer = this.#peers.get(event.from);
+        if (peer && event.session !== undefined && peer.session !== undefined && peer.session !== event.session) {
+            peer.close();
+            peer = undefined;
+        }
+        //A member whose joining was not seen (it joined while the signaling was reconnecting)
+        peer ??= this.#add(event.from, undefined, event.session);
+        peer.receive(signal);
+    }
+    /**
+     * The peer of the media server: created once, its connection carrying the media of all the members. When it replaces
+     * another one, the peers of the members, which used the connection to that one, are replaced too
+     * @param metadata
+     * @param session
+     */
+    #serverPeer(metadata, session) {
+        if (this.#server && !this.#server.closed)
+            return this.#server;
+        const members = this.#serverGone();
+        const roomHost = this.#host;
+        const host = {
+            localId: this.#host.localId,
+            create: () => this.#host.create({ headerExtensions: true }),
+            send: (to, signal) => this.#host.send(this.name, to, signal),
+            get signalingUp() {
+                return roomHost.signalingUp;
+            },
+            closed: (closed) => {
+                if (this.#server === closed)
+                    this.#control = undefined;
+            },
+            //The media server never gives up its offers
+            polite: true
+        };
+        const server = new Peer_js_1.Peer(host, this.#sfu, metadata, session);
+        this.#server = server;
+        for (const member of members)
+            this.#add(member.peerId, member.metadata, member.session, member.sfu);
+        server.on('error', (error) => void this.emit('error', error, server));
+        server.on('track', (event) => {
+            this.#unrouted.push(event);
+            if (this.#unrouted.length > MAX_UNROUTED)
+                this.#unrouted.shift();
+            this.#route();
+        });
+        server.on('datachannel', (channel) => {
+            //Its messages wait with it, given again once its peer has it
+            const early = [];
+            const keep = (event) => early.push(event.data);
+            channel.addEventListener('message', keep);
+            this.#unroutedChannels.push({ channel: channel, early: early, keep: keep });
+            if (this.#unroutedChannels.length > MAX_UNROUTED)
+                this.#unroutedChannels.shift().channel.close();
+            this.#route();
+        });
+        //The server offers first: Chrome cannot answer it after rolling back an offer of its own whose data channel had
+        //another media id ("Failed to start SCTP transport")
+        server.ready.then(() => server.negotiated).then(() => {
+            if (server.closed)
+                return;
+            //The control channel, negotiated by both sides
+            const control = server.connection.createDataChannel(SignalingProtocol_js_1.SignalingControlChannel.label, { negotiated: true, id: SignalingProtocol_js_1.SignalingControlChannel.id });
+            this.#control = control;
+            control.addEventListener('open', () => {
+                for (const message of this.#controls.splice(0))
+                    control.send(message);
+            });
+            for (const track of this.#published.keys())
+                this.#sendLater(server, track);
+        }, (error) => {
+            this.emit('error', error, server);
+            server.close();
+        });
+        return server;
+    }
+    /**
+     * The media server of the room is gone: its peer is closed, with what came through it, and the peers of the members,
+     * whose channels went through it (as when the members join again with a new session)
+     * @returns The members whose peer was closed.
+     */
+    #serverGone() {
+        const server = this.#server;
+        if (!server)
+            return [];
+        const members = [];
+        for (const peer of [...this.#peers.values()]) {
+            members.push({ peerId: peer.id, metadata: peer.metadata, session: peer.session, sfu: this.#serversOf.get(peer) });
+            peer.close();
+        }
+        server.close();
+        this.#control = undefined;
+        this.#controls.length = 0;
+        //The next one gives other streams the same ids
+        this.#streams.clear();
+        this.#unrouted.length = 0;
+        for (const { channel } of this.#unroutedChannels.splice(0))
+            channel.close();
+        for (const publication of this.#published.values()) {
+            for (const connection of [...publication.transceivers.keys()])
+                if (connection === server.connection)
+                    publication.transceivers.delete(connection);
+        }
+        return members;
+    }
+    /**
+     * Give the tracks and the channels received through the media server to the peers of their members: a track by its
+     * stream, a channel by its protocol
+     */
+    #route() {
+        for (const event of [...this.#unrouted]) {
+            const id = event.streams?.[0]?.id;
+            const stream = id === undefined ? undefined : this.#streams.get(id);
+            const peer = stream ? this.#peers.get(stream.peerId) : undefined;
+            if (!peer || !this.#ready.has(peer))
+                continue;
+            this.#unrouted.splice(this.#unrouted.indexOf(event), 1);
+            peer.relayedTrack(event);
+        }
+        for (const unrouted of [...this.#unroutedChannels]) {
+            const { channel, early, keep } = unrouted;
+            const peer = this.#peers.get(channel.protocol ?? '');
+            if (!peer || !this.#ready.has(peer))
+                continue;
+            this.#unroutedChannels.splice(this.#unroutedChannels.indexOf(unrouted), 1);
+            channel.removeEventListener('message', keep);
+            peer.relayedChannel(channel);
+            for (const data of early)
+                channel.dispatchEvent(new MessageEvent('message', { data: data }));
+        }
+    }
+    /**
+     * Send a message to the media server, once its control channel is open
+     * @param message
+     */
+    #controlSend(message) {
+        const data = JSON.stringify(message);
+        if (this.#control?.readyState === 'open') {
+            this.#control.send(data);
+        }
+        else {
+            this.#controls.push(data);
+        }
+    }
+    /**
+     * Send a track published on the connection of a peer: on a transceiver of a track unpublished, else on a new one
+     * (not one the other side offered, which may be receiving another track)
+     * @param peer
+     * @param track
+     */
+    async #send(peer, track) {
+        try {
+            await peer.ready;
+            if (peer === this.#server)
+                await peer.negotiated;
+        }
+        catch {
+            return;
+        }
+        const publication = this.#published.get(track);
+        const connection = peer.connection;
+        if (peer.closed || !publication || publication.transceivers.has(connection))
+            return;
+        const taken = new Set([...this.#published.values()].flatMap((each) => [...each.transceivers.values()]));
+        const reusable = connection.getTransceivers().find((transceiver) => this.#transceivers.has(transceiver)
+            && !taken.has(transceiver)
+            && !transceiver.sender.track
+            && transceiver.direction === 'inactive'
+            && transceiver.currentDirection === 'inactive'
+            && transceiver.receiver.track.kind === track.kind);
+        if (!reusable) {
+            const transceiver = connection.addTransceiver(track, { direction: 'sendonly', streams: publication.streams });
+            this.#transceivers.add(transceiver);
+            publication.transceivers.set(connection, transceiver);
+            return;
+        }
+        publication.transceivers.set(connection, reusable);
+        await reusable.sender.replaceTrack(track);
+        reusable.sender.setStreams(...publication.streams);
+        reusable.direction = 'sendonly';
+    }
+    /**
+     * Send a track published on the connection of a new peer; a failure is an error of the room
+     * @param peer
+     * @param track
+     */
+    #sendLater(peer, track) {
+        this.#send(peer, track).catch((error) => void this.emit('error', error, peer));
+    }
+    /**
+     * Create the peer of a member; the listeners of peer get it once its connection is created
+     * @param id
+     * @param metadata
+     * @param session
+     * @param sfu The media server the member is connected to.
+     */
+    #add(id, metadata, session, sfu) {
+        //With a media server, its connection
+        const relay = this.#sfu ? this.#serverPeer() : undefined;
+        const roomHost = this.#host;
+        const host = {
+            localId: this.#host.localId,
+            create: () => this.#host.create(),
+            send: (to, signal) => this.#host.send(this.name, to, signal),
+            get signalingUp() {
+                return roomHost.signalingUp;
+            },
+            closed: (closed) => {
+                if (this.#peers.get(closed.id) === closed)
+                    this.#peers.delete(closed.id);
+                for (const publication of this.#published.values()) {
+                    if (!this.#sfu && closed.connection)
+                        publication.transceivers.delete(closed.connection);
+                }
+                if (this.#ready.delete(closed))
+                    this.emit('peer-left', closed);
+            },
+            relay: relay,
+            ...relay ? { control: (message) => this.#controlSend(message) } : {}
+        };
+        const peer = new Peer_js_1.Peer(host, id, metadata, session);
+        this.#peers.set(id, peer);
+        if (sfu !== undefined)
+            this.#serversOf.set(peer, sfu);
+        peer.on('error', (error) => void this.emit('error', error, peer));
+        peer.ready.then(() => {
+            if (peer.closed)
+                return;
+            this.#ready.add(peer);
+            this.emit('peer', peer);
+            if (this.#sfu) {
+                this.#route();
+            }
+            else {
+                for (const track of this.#published.keys())
+                    this.#sendLater(peer, track);
+            }
+        }, (error) => {
+            this.emit('error', error, peer);
+            peer.close();
+        });
+        return peer;
+    }
+}
+exports.Room = Room;

package/dist/cjs/shared/SignalingError.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The error of a signaling request the server refused or did not answer: its `errno` is the one of the server's
+ * exception (`E_SIGNALING_DENIED`, `E_SIGNALING_NOT_A_MEMBER`, `E_SIGNALING_LIMIT`, `E_INVALID_VALUE`…), or
+ * `E_SIGNALING_TIMEOUT` and `E_SIGNALING_CLOSED` for the requests without an answer.
+ * @example
+ * ```typescript
+ * import {SignalingRequestError, type SignalingClient} from '@lakutata/webrtc'
+ *
+ * declare const signaling: SignalingClient
+ * try {
+ *     await signaling.join('private')
+ * } catch (error) {
+ *     if (error instanceof SignalingRequestError && error.errno === 'E_SIGNALING_DENIED') console.log('not allowed in the room')
+ * }
+ * ```
+ */
+export declare class SignalingRequestError extends Error {
+    /**
+     * The error number.
+     */
+    readonly errno: string | number;
+    /**
+     * The error the server sent, as it sent it.
+     */
+    readonly data?: unknown;
+    /**
+     * Create the error.
+     * @param message The message.
+     * @param errno The error number.
+     * @param data The error the server sent.
+     */
+    constructor(message: string, errno: string | number, data?: unknown);
+}
+/**
+ * The error of a response sent by the server: the properties of its exception (Socket.IO), or the data of a JSON-RPC
+ * error
+ * @param error
+ * @param fallbackMessage
+ */
+export declare function signalingErrorOf(error: unknown, fallbackMessage: string): SignalingRequestError;

package/dist/cjs/shared/SignalingError.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalingRequestError = void 0;
+exports.signalingErrorOf = signalingErrorOf;
+/**
+ * The error of a signaling request the server refused or did not answer: its `errno` is the one of the server's
+ * exception (`E_SIGNALING_DENIED`, `E_SIGNALING_NOT_A_MEMBER`, `E_SIGNALING_LIMIT`, `E_INVALID_VALUE`…), or
+ * `E_SIGNALING_TIMEOUT` and `E_SIGNALING_CLOSED` for the requests without an answer.
+ * @example
+ * ```typescript
+ * import {SignalingRequestError, type SignalingClient} from '@lakutata/webrtc'
+ *
+ * declare const signaling: SignalingClient
+ * try {
+ *     await signaling.join('private')
+ * } catch (error) {
+ *     if (error instanceof SignalingRequestError && error.errno === 'E_SIGNALING_DENIED') console.log('not allowed in the room')
+ * }
+ * ```
+ */
+class SignalingRequestError extends Error {
+    /**
+     * Create the error.
+     * @param message The message.
+     * @param errno The error number.
+     * @param data The error the server sent.
+     */
+    constructor(message, errno, data) {
+        super(message);
+        this.name = 'SignalingRequestError';
+        this.errno = errno;
+        this.data = data;
+    }
+}
+exports.SignalingRequestError = SignalingRequestError;
+/**
+ * The error of a response sent by the server: the properties of its exception (Socket.IO), or the data of a JSON-RPC
+ * error
+ * @param error
+ * @param fallbackMessage
+ */
+function signalingErrorOf(error, fallbackMessage) {
+    const object = (error && typeof error === 'object') ? error : {};
+    const data = (object.data && typeof object.data === 'object') ? object.data : object;
+    const message = data.errMsg ?? data.message ?? object.message;
+    const errno = data.errno ?? object.code ?? 'E_SIGNALING';
+    return new SignalingRequestError(typeof message === 'string' ? message : fallbackMessage, errno, error);
+}