msg91-webrtc-call/dist/index.js

**msg91-webrtc-call** is a lightweight JavaScript SDK that enables you to easily add peer-to-peer WebRTC audio/video calling functionality to your web applications.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const rtlayer_1 = require("./config/rtlayer");
const media_server_1 = require("./service/media-server");
const mediasoup_client_1 = require("mediasoup-client");
const client_1 = require("@11labs/client");
const util_1 = require("./util");
class EventEmitter {
    constructor() {
        this.eventListeners = {};
    }
    on(event, callback) {
        if (!this.eventListeners[event]) {
            this.eventListeners[event] = [];
        }
        this.eventListeners[event].push(callback);
    }
    emit(event, data) {
        const listeners = this.eventListeners[event];
        if (listeners) {
            for (const listener of listeners) {
                listener(data);
            }
        }
    }
    removeListener(channel, listener) {
        const listeners = this.eventListeners[channel] || [];
        const index = listeners.indexOf(listener);
        if (index !== -1) {
            listeners.splice(index, 1);
        }
        this.eventListeners[channel] = listeners;
    }
}
class WebRTC {
    constructor(userToken) {
        this.status = 'idle';
        this.eventListeners = {};
        this.user = {};
        this.userToken = userToken;
        (0, media_server_1.getUserData)(userToken).then((user) => {
            this.user.id = user === null || user === void 0 ? void 0 : user.id;
            this.user.name = user === null || user === void 0 ? void 0 : user.name;
            rtlayer_1.default.on(`user:${this.user.id}:call`, (data) => {
                data = JSON.parse(data);
                let call = null;
                data.token = this.callToken || data.callToken;
                switch (data.type) {
                    case 'incoming-call':
                        call = new IncommingCall(this.user, userToken, data);
                        break;
                    case 'outgoing-call':
                        if (this.callId != data.id)
                            break;
                        call = new OutgoingCall(this.user, userToken, data);
                        break;
                    case 'bot-call':
                        call = new BotCall(this.user, userToken, data);
                        break;
                    default:
                        console.error("Invalid call type");
                        break;
                }
                // const call = data?.type == 'incoming-call' ? new IncommingCall(this.user, userToken, data) : new OutgoingCall(this.user, userToken, data);
                if (call)
                    this.emit("call", call);
            });
            console.log("USER REGISTERED : ", this.user);
        }).catch((error) => {
            console.error("USER REGISTRATION UN-SUCCESSFUL", error);
        });
    }
    close() {
        rtlayer_1.default.unsubscribe(`user:${this.user.id}:call`);
    }
    async call(callToken) {
        let retryCount = 0;
        while (!rtlayer_1.default.isOpen() && retryCount++ < 10) {
            await new Promise(resolve => setTimeout(resolve, 300));
        }
        this.callToken = callToken;
        const { id } = await (0, media_server_1.startNewCall)(callToken);
        this.status = 'calling';
        this.callId = id;
    }
    async rejoinCall(callId) {
        this.callId = callId;
        let retryCount = 0;
        while (!rtlayer_1.default.isOpen() && retryCount++ < 10) {
            await new Promise(resolve => setTimeout(resolve, 300));
        }
        const { id, message, error } = await (0, media_server_1.rejoinCall)(callId, this.userToken);
        this.status = 'calling';
        this.callId = id;
        if (error) {
            throw new Error(message);
        }
    }
    async sendUserContext(data) {
        if (!data)
            return;
        try {
            await (0, media_server_1.sendUserContext)(this.userToken, data);
        }
        catch (error) {
            console.error("Error sending user data:", error);
        }
    }
    on(event, callback) {
        if (!this.eventListeners[event]) {
            this.eventListeners[event] = [];
        }
        this.eventListeners[event].push(callback);
        return {
            remove: () => {
                this.removeListener(event, callback);
            }
        };
    }
    removeListener(channel, listener) {
        const listeners = this.eventListeners[channel] || [];
        const index = listeners.indexOf(listener);
        if (index !== -1) {
            listeners.splice(index, 1);
        }
        this.eventListeners[channel] = listeners;
    }
    emit(event, data) {
        const listeners = this.eventListeners[event];
        if (listeners) {
            for (const listener of listeners) {
                listener(data);
            }
        }
    }
}
class Call extends EventEmitter {
    constructor(user, userToken, data) {
        super();
        this.existingCall = false;
        this.status = 'idle';
        this.audioTrack = null;
        this.rtlayerEvents = [];
        this.userToken = userToken;
        this.user = user;
        this.id = data.id;
        this.from = data.from;
        this.to = data.to;
        this.type = data.type;
        this.producerTransport = data.producerTransport;
        this.consumerTransport = data.consumerTransport;
        this.routerRtpCapabilities = data.routerRtpCapabilities;
        this.device = new mediasoup_client_1.Device();
        this.mediaStream = new MediaStream();
        this.existingCall = (data === null || data === void 0 ? void 0 : data.status) == 'connected' ? true : false;
    }
    addEvent(callback) {
        this.rtlayerEvents.push(callback);
    }
    async setStatus(status) {
        this.status = status;
    }
    getStatus() {
        return this.status;
    }
    getMediaStream() {
        return this.mediaStream;
    }
    isExistingCall() {
        return this.existingCall;
    }
    mute() {
        if (this.audioTrack) {
            this.audioTrack.enabled = false;
            this.emit("mute", { uid: this.user.id });
        }
    }
    unmute() {
        if (this.audioTrack) {
            this.audioTrack.enabled = true;
            this.emit("unmute", { uid: this.user.id });
        }
    }
    // Disconnect the connected call
    hang() {
        var _a;
        (_a = this.audioTrack) === null || _a === void 0 ? void 0 : _a.stop();
        this.audioTrack = null;
        this.mediaStream.getTracks().forEach(track => track === null || track === void 0 ? void 0 : track.stop());
        this.mediaStream = new MediaStream();
        this.setStatus("idle");
        (0, media_server_1.endCall)(this.id, this.userToken);
        setTimeout(() => {
            this.rtlayerEvents.forEach((event) => event === null || event === void 0 ? void 0 : event.remove());
        }, 2000);
    }
    async getInfo() {
        return {
            id: this.id,
            from: this.from,
            to: this.to,
            type: this.type,
        };
    }
    async setupCall() {
        await this.device.load({ routerRtpCapabilities: this.routerRtpCapabilities });
        const pTransport = this.device.createSendTransport(this.producerTransport);
        const cTransport = this.device.createRecvTransport(this.consumerTransport);
        pTransport.on('connect', async ({ dtlsParameters }, callback, errback) => {
            try {
                console.log("----------> producer transport has connected");
                // Notify the server that the transport is ready to connect with the provided DTLS parameters
                // socket.emit("connectProducerTransport", { dtlsParameters });
                await (0, media_server_1.joinCall)(this.user.id, this.id, dtlsParameters, "producer");
                // Callback to indicate success
                callback();
            }
            catch (error) {
                // Errback to indicate failure
                errback(error);
            }
        });
        pTransport.on("produce", async (parameters, callback, errback) => {
            const { kind, rtpParameters } = parameters;
            console.log("----------> transport-produce");
            try {
                // Notify the server to start producing media with the provided parameters
                const response = await (0, media_server_1.startProducing)(this.user.id, this.id, kind, rtpParameters);
                console.log(response);
                callback({ id: response.id });
                // socket.emit(
                //   "transport-produce",
                //   { kind, rtpParameters },
                //   ({ id }: any) => {
                //     // Callback to provide the server-generated producer ID back to the transport
                //     callback({ id });
                //   }
                // );
            }
            catch (error) {
                // Errback to indicate failure
                errback(error);
            }
        });
        cTransport.on('connect', async ({ dtlsParameters }, callback, errback) => {
            try {
                console.log("----------> consumer transport has connected");
                // Notify the server that the transport is ready to connect with the provided DTLS parameters
                // socket.emit("connectProducerTransport", { dtlsParameters });
                await (0, media_server_1.joinCall)(this.user.id, this.id, dtlsParameters, "consumer");
                // Callback to indicate success
                callback();
            }
            catch (error) {
                // Errback to indicate failure
                errback(error);
            }
        });
        const consumerEvents = rtlayer_1.default.on(`user:${this.user.id}:call:${this.id}:consume`, async (data) => {
            data = JSON.parse(data);
            let consumer = await cTransport.consume({
                id: data.id,
                producerId: data.producerId,
                kind: data.kind,
                rtpParameters: data.rtpParameters
            });
            console.log("----------> consumer created");
            if (!consumer)
                return;
            const { track } = consumer;
            console.log("TRACK", track);
            this.mediaStream.addTrack(track);
            this.emit("connected", this.mediaStream);
        });
        this.rtlayerEvents.push(consumerEvents);
        try {
            let stream = await navigator.mediaDevices.getUserMedia({
                audio: true,
                // video: true,
            });
            const audioTrack = stream === null || stream === void 0 ? void 0 : stream.getAudioTracks()[0];
            this.audioTrack = audioTrack;
            await pTransport.produce({
                track: audioTrack,
            });
        }
        catch (error) {
            this.emit("error", { message: "Unable to access microphone", error: error });
        }
    }
}
class IncommingCall extends Call {
    constructor(user, userToken, data) {
        super(user, userToken, data);
        this.isUnavailable = false;
        if (this.existingCall) {
            this.rejoin(data);
        }
        const callEvents = rtlayer_1.default.on(`call:${data.id}`, (data) => {
            var _a;
            data = JSON.parse(data);
            switch (data.type) {
                case 'call-ended': {
                    this.emit("ended", data);
                    this.hang();
                    break;
                }
                case 'call-answered': {
                    if (((_a = data.answeredBy) === null || _a === void 0 ? void 0 : _a.id) != user.id) {
                        this.isUnavailable = true;
                        this.emit("unavailable", data);
                    }
                    break;
                }
                default: {
                    console.error("Invalid call type");
                    return;
                }
            }
        });
        this.addEvent(callEvents);
    }
    rejoin(data) {
        this.isUnavailable = false;
        super.setupCall();
        super.setStatus("oncall");
        setTimeout(() => {
            this.emit("rejoined", data);
        }, 100);
    }
    accept() {
        if (this.isUnavailable)
            return;
        if (this.existingCall)
            return;
        super.setupCall();
        super.setStatus("oncall");
    }
    reject() {
        super.hang();
    }
}
class OutgoingCall extends Call {
    constructor(user, userToken, data) {
        super(user, userToken, data);
        if (this.existingCall) {
            this.rejoin(data);
        }
        super.setupCall();
        const callEvents = rtlayer_1.default.on(`call:${data.id}`, (data) => {
            data = JSON.parse(data);
            switch (data.type) {
                case 'call-ended': {
                    this.emit("ended", data);
                    this.cancel();
                    break;
                }
                case 'call-answered': {
                    if (this.getStatus() == "oncall")
                        return;
                    this.emit("answered", data);
                    this.setStatus("oncall");
                    break;
                }
                default: {
                    console.error("Invalid call type");
                    return;
                }
            }
        });
        this.addEvent(callEvents);
        const botEvents = rtlayer_1.default.on(`user:${this.user.id}:call:${this.id}:bot`, (data) => {
            data = JSON.parse(data);
            if (data.type == "message") {
                this.emit("message", { message: data === null || data === void 0 ? void 0 : data.message });
            }
        });
        this.addEvent(botEvents);
    }
    rejoin(data) {
        // Join the call without ringing
        // Hydrate call details by triggering rejoin event
        setTimeout(() => {
            this.emit("rejoined", data);
        }, 100);
    }
    cancel() {
        super.hang();
    }
}
class BotCall extends Call {
    constructor(user, userToken, data) {
        super(user, userToken, data);
        if (this.existingCall) {
            this.rejoin(data);
        }
        this.setupCall();
        super.setStatus("oncall");
        this.data = data;
        rtlayer_1.default.on(`call:${data.id}`, (data) => {
            data = JSON.parse(data);
            if (data.type == 'call-ended') {
                this.emit("ended", data);
            }
            if (data.type == 'call-answered') {
                this.emit("answered", data);
            }
        });
    }
    async setupCall() {
        var _a, _b, _c, _d;
        try {
            await navigator.mediaDevices.getUserMedia({ audio: true });
        }
        catch (error) {
            this.emit("error", { message: "Unable to access microphone", error: error });
        }
        const bot = (_a = this.data) === null || _a === void 0 ? void 0 : _a.bot;
        if (!(bot === null || bot === void 0 ? void 0 : bot.url))
            return this.emit("error", { message: "You are not authorized to access this bot." });
        this.conversation = await client_1.Conversation.startSession({
            signedUrl: bot === null || bot === void 0 ? void 0 : bot.url,
            agentId: bot === null || bot === void 0 ? void 0 : bot.agentId,
            clientTools: {
                transferToHuman: async () => {
                    var _a;
                    console.info("Transfering call to human");
                    const callToken = (_a = this.data) === null || _a === void 0 ? void 0 : _a.token;
                    this.hang();
                    if (!callToken)
                        return this.emit("error", { message: "Call token is missing." });
                    await (0, media_server_1.startNewCall)(callToken, true);
                },
                endCall: async () => {
                    console.info("Ending the call");
                    this.hang();
                },
                importantMessage: async ({ text }) => {
                    console.info("Important information received:", text);
                    this.emit("message", { message: text });
                }
            }
        });
        this.callId = this.conversation.getId();
        this.emit("answered", {
            id: this.id,
            answeredBy: (_b = this.data) === null || _b === void 0 ? void 0 : _b.bot,
            answeredAt: ((_d = (_c = this.data) === null || _c === void 0 ? void 0 : _c.summary) === null || _d === void 0 ? void 0 : _d.answeredAt) || new Date(),
            type: "call-answered",
            message: "Call answered"
        });
    }
    rejoin(data) {
        setTimeout(() => {
            this.emit("rejoined", data);
        }, 100);
    }
    cancel() {
        var _a;
        (_a = this.conversation) === null || _a === void 0 ? void 0 : _a.endSession();
        this.emit("ended", {
            id: this.id,
            endedAt: new Date(),
            type: "call-ended",
            message: "Call ended"
        });
        this.setStatus("idle");
    }
    mute() {
        // this.conversation?.setMicMuted(true);
        this.emit("mute", { uid: this.user.id });
    }
    sendContext(context) {
        if (!context || !context.text)
            return this.emit("error", { message: "Context is missing." });
        if (!this.conversation)
            return this.emit("error", { message: "Conversation not started." });
        this.conversation.sendContextualUpdate(context.text);
    }
    unmute() {
        // this.conversation?.setMicMuted(false);
        this.emit("unmute", { uid: this.user.id });
    }
    hang() {
        var _a;
        (_a = this.conversation) === null || _a === void 0 ? void 0 : _a.endSession();
        this.setStatus("idle");
        this.emit("ended", {
            id: this.id,
            endedAt: new Date(),
            type: "call-ended",
            message: "Call ended"
        });
        (0, media_server_1.endCall)(this.id, this.userToken);
    }
}
let webrtc = new Map();
exports.default = (userToken, env = "prod") => {
    (0, util_1.setEnvironment)(env);
    if (webrtc.has(userToken))
        return webrtc.get(userToken);
    webrtc.set(userToken, new WebRTC(userToken));
    return webrtc.get(userToken);
};