mediasfu-shared 1.0.6 → 1.2.0

package/dist/joinRoomOnMediaSFU-y6vJ1OBo.js

@@ -0,0 +1,1223 @@
+var cookie = {};
+/*!
+ * cookie
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+var hasRequiredCookie;
+function requireCookie() {
+  if (hasRequiredCookie) return cookie;
+  hasRequiredCookie = 1;
+  cookie.parse = parse;
+  cookie.serialize = serialize;
+  var __toString = Object.prototype.toString;
+  var __hasOwnProperty = Object.prototype.hasOwnProperty;
+  var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+  var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/;
+  var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+  var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+  function parse(str, opt) {
+    if (typeof str !== "string") {
+      throw new TypeError("argument str must be a string");
+    }
+    var obj = {};
+    var len = str.length;
+    if (len < 2) return obj;
+    var dec = opt && opt.decode || decode;
+    var index = 0;
+    var eqIdx = 0;
+    var endIdx = 0;
+    do {
+      eqIdx = str.indexOf("=", index);
+      if (eqIdx === -1) break;
+      endIdx = str.indexOf(";", index);
+      if (endIdx === -1) {
+        endIdx = len;
+      } else if (eqIdx > endIdx) {
+        index = str.lastIndexOf(";", eqIdx - 1) + 1;
+        continue;
+      }
+      var keyStartIdx = startIndex(str, index, eqIdx);
+      var keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
+      var key = str.slice(keyStartIdx, keyEndIdx);
+      if (!__hasOwnProperty.call(obj, key)) {
+        var valStartIdx = startIndex(str, eqIdx + 1, endIdx);
+        var valEndIdx = endIndex(str, endIdx, valStartIdx);
+        if (str.charCodeAt(valStartIdx) === 34 && str.charCodeAt(valEndIdx - 1) === 34) {
+          valStartIdx++;
+          valEndIdx--;
+        }
+        var val = str.slice(valStartIdx, valEndIdx);
+        obj[key] = tryDecode(val, dec);
+      }
+      index = endIdx + 1;
+    } while (index < len);
+    return obj;
+  }
+  function startIndex(str, index, max) {
+    do {
+      var code = str.charCodeAt(index);
+      if (code !== 32 && code !== 9) return index;
+    } while (++index < max);
+    return max;
+  }
+  function endIndex(str, index, min) {
+    while (index > min) {
+      var code = str.charCodeAt(--index);
+      if (code !== 32 && code !== 9) return index + 1;
+    }
+    return min;
+  }
+  function serialize(name, val, opt) {
+    var enc = opt && opt.encode || encodeURIComponent;
+    if (typeof enc !== "function") {
+      throw new TypeError("option encode is invalid");
+    }
+    if (!cookieNameRegExp.test(name)) {
+      throw new TypeError("argument name is invalid");
+    }
+    var value = enc(val);
+    if (!cookieValueRegExp.test(value)) {
+      throw new TypeError("argument val is invalid");
+    }
+    var str = name + "=" + value;
+    if (!opt) return str;
+    if (null != opt.maxAge) {
+      var maxAge = Math.floor(opt.maxAge);
+      if (!isFinite(maxAge)) {
+        throw new TypeError("option maxAge is invalid");
+      }
+      str += "; Max-Age=" + maxAge;
+    }
+    if (opt.domain) {
+      if (!domainValueRegExp.test(opt.domain)) {
+        throw new TypeError("option domain is invalid");
+      }
+      str += "; Domain=" + opt.domain;
+    }
+    if (opt.path) {
+      if (!pathValueRegExp.test(opt.path)) {
+        throw new TypeError("option path is invalid");
+      }
+      str += "; Path=" + opt.path;
+    }
+    if (opt.expires) {
+      var expires = opt.expires;
+      if (!isDate(expires) || isNaN(expires.valueOf())) {
+        throw new TypeError("option expires is invalid");
+      }
+      str += "; Expires=" + expires.toUTCString();
+    }
+    if (opt.httpOnly) {
+      str += "; HttpOnly";
+    }
+    if (opt.secure) {
+      str += "; Secure";
+    }
+    if (opt.partitioned) {
+      str += "; Partitioned";
+    }
+    if (opt.priority) {
+      var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+      switch (priority) {
+        case "low":
+          str += "; Priority=Low";
+          break;
+        case "medium":
+          str += "; Priority=Medium";
+          break;
+        case "high":
+          str += "; Priority=High";
+          break;
+        default:
+          throw new TypeError("option priority is invalid");
+      }
+    }
+    if (opt.sameSite) {
+      var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+      switch (sameSite) {
+        case true:
+          str += "; SameSite=Strict";
+          break;
+        case "lax":
+          str += "; SameSite=Lax";
+          break;
+        case "strict":
+          str += "; SameSite=Strict";
+          break;
+        case "none":
+          str += "; SameSite=None";
+          break;
+        default:
+          throw new TypeError("option sameSite is invalid");
+      }
+    }
+    return str;
+  }
+  function decode(str) {
+    return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+  }
+  function isDate(val) {
+    return __toString.call(val) === "[object Date]";
+  }
+  function tryDecode(str, decode2) {
+    try {
+      return decode2(str);
+    } catch (e) {
+      return str;
+    }
+  }
+  return cookie;
+}
+var cookieExports = requireCookie();
+function hasDocumentCookie() {
+  const testingValue = typeof global === "undefined" ? void 0 : global.TEST_HAS_DOCUMENT_COOKIE;
+  if (typeof testingValue === "boolean") {
+    return testingValue;
+  }
+  return typeof document === "object" && typeof document.cookie === "string";
+}
+function parseCookies(cookies2) {
+  if (typeof cookies2 === "string") {
+    return cookieExports.parse(cookies2);
+  } else if (typeof cookies2 === "object" && cookies2 !== null) {
+    return cookies2;
+  } else {
+    return {};
+  }
+}
+function readCookie(value, options = {}) {
+  const cleanValue = cleanupCookieValue(value);
+  if (!options.doNotParse) {
+    try {
+      return JSON.parse(cleanValue);
+    } catch (e) {
+    }
+  }
+  return value;
+}
+function cleanupCookieValue(value) {
+  if (value && value[0] === "j" && value[1] === ":") {
+    return value.substr(2);
+  }
+  return value;
+}
+class Cookies {
+  constructor(cookies2, defaultSetOptions = {}) {
+    this.changeListeners = [];
+    this.HAS_DOCUMENT_COOKIE = false;
+    this.update = () => {
+      if (!this.HAS_DOCUMENT_COOKIE) {
+        return;
+      }
+      const previousCookies = this.cookies;
+      this.cookies = cookieExports.parse(document.cookie);
+      this._checkChanges(previousCookies);
+    };
+    const domCookies = typeof document === "undefined" ? "" : document.cookie;
+    this.cookies = parseCookies(cookies2 || domCookies);
+    this.defaultSetOptions = defaultSetOptions;
+    this.HAS_DOCUMENT_COOKIE = hasDocumentCookie();
+  }
+  _emitChange(params) {
+    for (let i = 0; i < this.changeListeners.length; ++i) {
+      this.changeListeners[i](params);
+    }
+  }
+  _checkChanges(previousCookies) {
+    const names = new Set(Object.keys(previousCookies).concat(Object.keys(this.cookies)));
+    names.forEach((name) => {
+      if (previousCookies[name] !== this.cookies[name]) {
+        this._emitChange({
+          name,
+          value: readCookie(this.cookies[name])
+        });
+      }
+    });
+  }
+  _startPolling() {
+    this.pollingInterval = setInterval(this.update, 300);
+  }
+  _stopPolling() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+    }
+  }
+  get(name, options = {}) {
+    if (!options.doNotUpdate) {
+      this.update();
+    }
+    return readCookie(this.cookies[name], options);
+  }
+  getAll(options = {}) {
+    if (!options.doNotUpdate) {
+      this.update();
+    }
+    const result = {};
+    for (let name in this.cookies) {
+      result[name] = readCookie(this.cookies[name], options);
+    }
+    return result;
+  }
+  set(name, value, options) {
+    if (options) {
+      options = Object.assign(Object.assign({}, this.defaultSetOptions), options);
+    } else {
+      options = this.defaultSetOptions;
+    }
+    const stringValue = typeof value === "string" ? value : JSON.stringify(value);
+    this.cookies = Object.assign(Object.assign({}, this.cookies), { [name]: stringValue });
+    if (this.HAS_DOCUMENT_COOKIE) {
+      document.cookie = cookieExports.serialize(name, stringValue, options);
+    }
+    this._emitChange({ name, value, options });
+  }
+  remove(name, options) {
+    const finalOptions = options = Object.assign(Object.assign(Object.assign({}, this.defaultSetOptions), options), { expires: new Date(1970, 1, 1, 0, 0, 1), maxAge: 0 });
+    this.cookies = Object.assign({}, this.cookies);
+    delete this.cookies[name];
+    if (this.HAS_DOCUMENT_COOKIE) {
+      document.cookie = cookieExports.serialize(name, "", finalOptions);
+    }
+    this._emitChange({ name, value: void 0, options });
+  }
+  addChangeListener(callback) {
+    this.changeListeners.push(callback);
+    if (this.HAS_DOCUMENT_COOKIE && this.changeListeners.length === 1) {
+      if (typeof window === "object" && "cookieStore" in window) {
+        window.cookieStore.addEventListener("change", this.update);
+      } else {
+        this._startPolling();
+      }
+    }
+  }
+  removeChangeListener(callback) {
+    const idx = this.changeListeners.indexOf(callback);
+    if (idx >= 0) {
+      this.changeListeners.splice(idx, 1);
+    }
+    if (this.HAS_DOCUMENT_COOKIE && this.changeListeners.length === 0) {
+      if (typeof window === "object" && "cookieStore" in window) {
+        window.cookieStore.removeEventListener("change", this.update);
+      } else {
+        this._stopPolling();
+      }
+    }
+  }
+}
+const cookies = new Cookies();
+const MAX_ATTEMPTS = 10;
+const RATE_LIMIT_DURATION = 3 * 60 * 60 * 1e3;
+const readStoredNumber = async (adapter, key) => {
+  const value = await adapter.getItem(key);
+  const parsed = parseInt((value ?? "0").toString(), 10);
+  return Number.isNaN(parsed) ? 0 : parsed;
+};
+const writeStoredNumber = async (adapter, key, value) => {
+  await adapter.setItem(key, value.toString());
+};
+const hasConnectedSocketId = (socket) => {
+  if (!socket || typeof socket !== "object") {
+    return false;
+  }
+  const candidate = socket;
+  return typeof candidate.id === "string" && candidate.id.length > 0;
+};
+const checkLimitsAndMakeRequestWithStorage = async ({
+  apiUserName,
+  apiToken,
+  link,
+  apiKey = "",
+  userName,
+  parameters,
+  validate = true,
+  storageAdapter
+}) => {
+  const TIMEOUT_DURATION = 1e4;
+  try {
+    let unsuccessfulAttempts = await readStoredNumber(storageAdapter, "unsuccessfulAttempts");
+    const lastRequestTimestamp = await readStoredNumber(storageAdapter, "lastRequestTimestamp");
+    if (unsuccessfulAttempts >= MAX_ATTEMPTS && Date.now() - lastRequestTimestamp < RATE_LIMIT_DURATION) {
+      parameters.showAlert?.({
+        message: "Too many unsuccessful attempts. Please try again later.",
+        type: "danger",
+        duration: 3e3
+      });
+      await writeStoredNumber(storageAdapter, "lastRequestTimestamp", Date.now());
+      return;
+    }
+    if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+      unsuccessfulAttempts = 0;
+      await writeStoredNumber(storageAdapter, "unsuccessfulAttempts", unsuccessfulAttempts);
+      await writeStoredNumber(storageAdapter, "lastRequestTimestamp", Date.now());
+    }
+    parameters.updateIsLoadingModalVisible(true);
+    const socketPromise = parameters.connectSocket({
+      apiUserName,
+      apiKey,
+      apiToken,
+      link
+    });
+    const timeoutPromise = new Promise((_, reject) => setTimeout(
+      () => reject(new Error("Request timed out")),
+      TIMEOUT_DURATION
+    ));
+    const socket = await Promise.race([socketPromise, timeoutPromise]);
+    if (hasConnectedSocketId(socket)) {
+      unsuccessfulAttempts = 0;
+      await writeStoredNumber(storageAdapter, "unsuccessfulAttempts", unsuccessfulAttempts);
+      await writeStoredNumber(storageAdapter, "lastRequestTimestamp", Date.now());
+      if (validate) {
+        parameters.updateSocket(socket);
+      } else {
+        parameters.updateLocalSocket?.(socket);
+      }
+      parameters.updateApiUserName(apiUserName);
+      parameters.updateApiToken(apiToken);
+      parameters.updateLink(link);
+      parameters.updateRoomName(apiUserName);
+      parameters.updateMember(userName);
+      if (validate) {
+        parameters.updateValidated(true);
+      }
+    } else {
+      unsuccessfulAttempts += 1;
+      await writeStoredNumber(storageAdapter, "unsuccessfulAttempts", unsuccessfulAttempts);
+      await writeStoredNumber(storageAdapter, "lastRequestTimestamp", Date.now());
+      parameters.updateIsLoadingModalVisible(false);
+      if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+        parameters.showAlert?.({
+          message: "Too many unsuccessful attempts. Please try again later.",
+          type: "danger",
+          duration: 3e3
+        });
+      } else {
+        parameters.showAlert?.({
+          message: "Invalid credentials.",
+          type: "danger",
+          duration: 3e3
+        });
+      }
+    }
+  } catch (error) {
+    console.error("Error connecting to socket:", error);
+    parameters.showAlert?.({
+      message: "Unable to connect. Check your credentials and try again.",
+      type: "danger",
+      duration: 3e3
+    });
+    let unsuccessfulAttempts = await readStoredNumber(storageAdapter, "unsuccessfulAttempts");
+    unsuccessfulAttempts += 1;
+    await writeStoredNumber(storageAdapter, "unsuccessfulAttempts", unsuccessfulAttempts);
+    await writeStoredNumber(storageAdapter, "lastRequestTimestamp", Date.now());
+    parameters.updateIsLoadingModalVisible(false);
+  }
+};
+const checkLimitsAndMakeRequest = async ({
+  apiUserName,
+  apiToken,
+  link,
+  apiKey = "",
+  userName,
+  parameters,
+  validate = true
+}) => {
+  const TIMEOUT_DURATION = 1e4;
+  let unsuccessfulAttempts = parseInt(cookies.get("unsuccessfulAttempts")) || 0;
+  let lastRequestTimestamp = parseInt(cookies.get("lastRequestTimestamp")) || 0;
+  if (unsuccessfulAttempts >= MAX_ATTEMPTS && Date.now() - lastRequestTimestamp < RATE_LIMIT_DURATION) {
+    parameters.showAlert?.({
+      message: "Too many unsuccessful attempts. Please try again later.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  } else {
+    unsuccessfulAttempts = 0;
+    cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+    cookies.set("lastRequestTimestamp", Date.now().toString());
+  }
+  try {
+    parameters.updateIsLoadingModalVisible(true);
+    const socketPromise = await parameters.connectSocket({
+      apiUserName,
+      apiKey,
+      apiToken,
+      link
+    });
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error("Request timed out")),
+        TIMEOUT_DURATION
+      )
+    );
+    const socket = await Promise.race([socketPromise, timeoutPromise]);
+    if (hasConnectedSocketId(socket)) {
+      unsuccessfulAttempts = 0;
+      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      cookies.set("lastRequestTimestamp", Date.now().toString());
+      if (validate) {
+        parameters.updateSocket(socket);
+      } else {
+        parameters.updateLocalSocket?.(socket);
+      }
+      parameters.updateApiUserName(apiUserName);
+      parameters.updateApiToken(apiToken);
+      parameters.updateLink(link);
+      parameters.updateRoomName(apiUserName);
+      parameters.updateMember(userName);
+      if (validate) parameters.updateValidated(true);
+    } else {
+      unsuccessfulAttempts += 1;
+      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      parameters.updateIsLoadingModalVisible(false);
+      parameters.showAlert?.({
+        message: "Invalid credentials.",
+        type: "danger",
+        duration: 3e3
+      });
+    }
+  } catch {
+    parameters.showAlert?.({
+      message: "Unable to connect. Check your credentials and try again.",
+      type: "danger",
+      duration: 3e3
+    });
+    unsuccessfulAttempts += 1;
+    cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+    parameters.updateIsLoadingModalVisible(false);
+  }
+};
+const hostRequestResponse = async ({
+  requestResponse,
+  showAlert,
+  requestList,
+  updateRequestList,
+  updateMicAction,
+  updateVideoAction,
+  updateScreenAction,
+  updateChatAction,
+  updateAudioRequestState,
+  updateVideoRequestState,
+  updateScreenRequestState,
+  updateChatRequestState,
+  updateAudioRequestTime,
+  updateVideoRequestTime,
+  updateScreenRequestTime,
+  updateChatRequestTime,
+  updateRequestIntervalSeconds
+}) => {
+  const requestType = requestResponse.type ?? requestResponse.icon;
+  const filteredRequests = requestList.filter(
+    (request) => {
+      const matchesId = request.id === requestResponse.id;
+      const matchesType = requestType == null || request.icon === requestType;
+      const matchesName = requestResponse.name == null || request.name === requestResponse.name;
+      const matchesUsername = requestResponse.username == null || request.username === requestResponse.username;
+      return !(matchesId && matchesType && matchesName && matchesUsername);
+    }
+  );
+  updateRequestList(filteredRequests);
+  if (requestResponse.action === "accepted") {
+    switch (requestType) {
+      case "fa-microphone":
+        showAlert?.({
+          message: "Unmute request was accepted; click the mic button again to begin.",
+          type: "success",
+          duration: 1e4
+        });
+        updateMicAction(true);
+        updateAudioRequestState("accepted");
+        break;
+      case "fa-video":
+        showAlert?.({
+          message: "Video request was accepted; click the video button again to begin.",
+          type: "success",
+          duration: 1e4
+        });
+        updateVideoAction(true);
+        updateVideoRequestState("accepted");
+        break;
+      case "fa-desktop":
+        showAlert?.({
+          message: "Screenshare request was accepted; click the screen button again to begin.",
+          type: "success",
+          duration: 1e4
+        });
+        updateScreenAction(true);
+        updateScreenRequestState("accepted");
+        break;
+      case "fa-comments":
+        showAlert?.({
+          message: "Chat request was accepted; click the chat button again to begin.",
+          type: "success",
+          duration: 1e4
+        });
+        updateChatAction(true);
+        updateChatRequestState("accepted");
+        break;
+    }
+  } else {
+    let timerDate;
+    switch (requestType) {
+      case "fa-microphone":
+        showAlert?.({
+          message: "Unmute request was not accepted",
+          type: "danger",
+          duration: 1e4
+        });
+        updateAudioRequestState("rejected");
+        timerDate = /* @__PURE__ */ new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateAudioRequestTime(timerDate.getTime());
+        break;
+      case "fa-video":
+        showAlert?.({
+          message: "Video request was not accepted",
+          type: "danger",
+          duration: 1e4
+        });
+        updateVideoRequestState("rejected");
+        timerDate = /* @__PURE__ */ new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateVideoRequestTime(timerDate.getTime());
+        break;
+      case "fa-desktop":
+        showAlert?.({
+          message: "Screenshare request was not accepted",
+          type: "danger",
+          duration: 1e4
+        });
+        updateScreenRequestState("rejected");
+        timerDate = /* @__PURE__ */ new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateScreenRequestTime(timerDate.getTime());
+        break;
+      case "fa-comments":
+        showAlert?.({
+          message: "Chat request was not accepted",
+          type: "danger",
+          duration: 1e4
+        });
+        updateChatRequestState("rejected");
+        timerDate = /* @__PURE__ */ new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateChatRequestTime(timerDate.getTime());
+        break;
+    }
+  }
+};
+const clickAudio = async ({ parameters }) => {
+  let {
+    checkMediaPermission,
+    hasAudioPermission,
+    audioPaused,
+    audioAlreadyOn,
+    audioOnlyRoom,
+    recordStarted,
+    recordResumed,
+    recordPaused,
+    recordStopped,
+    recordingMediaOptions,
+    islevel,
+    youAreCoHost,
+    adminRestrictSetting,
+    audioRequestState,
+    audioRequestTime,
+    member,
+    socket,
+    localSocket,
+    roomName,
+    userDefaultAudioInputDevice,
+    micAction,
+    localStream,
+    audioSetting,
+    videoSetting,
+    screenshareSetting,
+    chatSetting,
+    updateRequestIntervalSeconds,
+    participants,
+    mediaDevices,
+    showAlert,
+    transportCreated,
+    transportCreatedAudio,
+    updateAudioAlreadyOn,
+    updateAudioRequestState,
+    updateAudioPaused,
+    updateLocalStream,
+    updateParticipants,
+    updateTransportCreated,
+    updateTransportCreatedAudio,
+    updateMicAction,
+    checkPermission,
+    streamSuccessAudio,
+    requestPermissionAudio,
+    resumeSendTransportAudio,
+    disconnectSendTransportAudio
+  } = parameters;
+  if (audioOnlyRoom) {
+    showAlert?.({
+      message: "You cannot turn on your camera in an audio-only event.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (audioAlreadyOn) {
+    if (islevel === "2" && (recordStarted || recordResumed)) {
+      if (!(recordPaused || recordStopped)) {
+        if (recordingMediaOptions === "audio") {
+          showAlert?.({
+            message: "You cannot turn off your audio while recording, please pause or stop recording first.",
+            type: "danger",
+            duration: 3e3
+          });
+          return;
+        }
+      }
+    }
+    audioAlreadyOn = false;
+    updateAudioAlreadyOn(audioAlreadyOn);
+    if (localStream && localStream.getAudioTracks().length > 0) {
+      localStream.getAudioTracks()[0].enabled = false;
+      updateLocalStream(localStream);
+    }
+    await disconnectSendTransportAudio({ parameters });
+    audioPaused = true;
+    updateAudioPaused(audioPaused);
+  } else {
+    if (adminRestrictSetting) {
+      showAlert?.({
+        message: "You cannot turn on your microphone. Access denied by host.",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+    const supportMaxRoom = parameters.supportMaxRoom;
+    const supportFlexRoom = parameters.supportFlexRoom;
+    if ((supportMaxRoom || supportFlexRoom) && islevel !== "2") {
+      try {
+        const checkResult = await new Promise((resolve) => {
+          socket.emit(
+            "checkProduce",
+            { kind: "audio" },
+            (response2) => {
+              resolve(response2 || { allowed: false, reason: "No response from server" });
+            }
+          );
+          setTimeout(() => resolve({ allowed: true }), 5e3);
+        });
+        if (!checkResult.allowed) {
+          showAlert?.({
+            message: checkResult.reason || `Audio producer limit reached (${checkResult.producingCount}/${checkResult.producerLimit}).`,
+            type: "danger",
+            duration: 3e3
+          });
+          return;
+        }
+      } catch (error) {
+        console.warn("Failed to check producer limit:", error);
+      }
+    }
+    const panelistsFocused = parameters.panelistsFocused;
+    const muteOthersMic = parameters.muteOthersMic;
+    const panelists = parameters.panelists;
+    if (panelistsFocused && muteOthersMic && islevel !== "2") {
+      const isPanelist = panelists?.some((panelist) => panelist.name === member) || false;
+      if (!isPanelist) {
+        showAlert?.({
+          message: "You cannot turn on your microphone. Only panelists can unmute while focus mode is active.",
+          type: "danger",
+          duration: 3e3
+        });
+        return;
+      }
+    }
+    let response = 2;
+    if (!micAction && islevel !== "2" && !youAreCoHost) {
+      response = await checkPermission({
+        permissionType: "audioSetting",
+        audioSetting,
+        videoSetting,
+        screenshareSetting,
+        chatSetting,
+        permissionConfig: parameters.permissionConfig,
+        participantLevel: islevel
+      });
+    } else {
+      response = 0;
+    }
+    switch (response) {
+      case 1: {
+        if (audioRequestState === "pending") {
+          showAlert?.({
+            message: "A request is pending. Please wait for the host to respond.",
+            type: "danger",
+            duration: 3e3
+          });
+          return;
+        }
+        if (audioRequestState === "rejected" && Date.now() - audioRequestTime < updateRequestIntervalSeconds * 1e3) {
+          showAlert?.({
+            message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,
+            type: "danger",
+            duration: 3e3
+          });
+          return;
+        }
+        showAlert?.({
+          message: "Request sent to host.",
+          type: "success",
+          duration: 3e3
+        });
+        audioRequestState = "pending";
+        updateAudioRequestState(audioRequestState);
+        const userRequest = {
+          id: socket.id,
+          name: member,
+          icon: "fa-microphone"
+        };
+        socket.emit("participantRequest", { userRequest, roomName });
+        break;
+      }
+      case 2:
+        showAlert?.({
+          message: "You cannot turn on your microphone. Access denied by host.",
+          type: "danger",
+          duration: 3e3
+        });
+        break;
+      case 0:
+        if (audioPaused) {
+          if (localStream && localStream.getAudioTracks().length > 0) {
+            localStream.getAudioTracks()[0].enabled = true;
+          }
+          updateAudioAlreadyOn(true);
+          await resumeSendTransportAudio({ parameters });
+          socket.emit("resumeProducerAudio", { mediaTag: "audio", roomName });
+          try {
+            if (localSocket && localSocket.id) {
+              localSocket.emit("resumeProducerAudio", { mediaTag: "audio", roomName });
+            }
+          } catch (error) {
+            console.log("Error in resumeProducerAudio", error);
+          }
+          updateLocalStream(localStream);
+          if (micAction === true) {
+            micAction = false;
+            updateMicAction(micAction);
+          }
+          participants.forEach((participant) => {
+            if (participant.socketId === socket.id && participant.name === member) {
+              participant.muted = false;
+            }
+          });
+          updateParticipants(participants);
+          transportCreated = true;
+          updateTransportCreated(transportCreated);
+          transportCreatedAudio = true;
+          updateTransportCreatedAudio(transportCreatedAudio);
+        } else {
+          if (!hasAudioPermission && checkMediaPermission) {
+            const statusMic = await requestPermissionAudio();
+            if (statusMic !== "granted") {
+              showAlert?.({
+                message: "Allow access to your microphone or check if your microphone is not being used by another application.",
+                type: "danger",
+                duration: 3e3
+              });
+              return;
+            }
+          }
+          const mediaConstraints = userDefaultAudioInputDevice ? { audio: { deviceId: userDefaultAudioInputDevice }, video: false } : { audio: true, video: false };
+          try {
+            const stream = await mediaDevices.getUserMedia(mediaConstraints);
+            await streamSuccessAudio({ stream, parameters });
+          } catch (error) {
+            console.error(error);
+            showAlert?.({
+              message: "Allow access to your microphone or check if your microphone is not being used by another application.",
+              type: "danger",
+              duration: 3e3
+            });
+          }
+        }
+        break;
+    }
+  }
+};
+const clickScreenShare = async ({ parameters }) => {
+  let {
+    showAlert,
+    roomName,
+    member,
+    socket,
+    islevel,
+    youAreCoHost,
+    adminRestrictSetting,
+    audioSetting,
+    videoSetting,
+    screenshareSetting,
+    chatSetting,
+    screenAction,
+    screenAlreadyOn,
+    screenRequestState,
+    screenRequestTime,
+    audioOnlyRoom,
+    updateRequestIntervalSeconds,
+    updateScreenRequestState,
+    updateScreenAlreadyOn,
+    checkPermission,
+    checkScreenShare,
+    stopShareScreen
+  } = parameters;
+  if (audioOnlyRoom) {
+    showAlert?.({
+      message: "You cannot turn on your camera in an audio-only event.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (screenAlreadyOn) {
+    screenAlreadyOn = false;
+    updateScreenAlreadyOn(screenAlreadyOn);
+    await stopShareScreen({ parameters });
+  } else {
+    if (adminRestrictSetting) {
+      showAlert?.({
+        message: "You cannot start screen share. Access denied by host.",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+    let response = 2;
+    if (!screenAction && islevel !== "2" && !youAreCoHost) {
+      response = await checkPermission({
+        permissionType: "screenshareSetting",
+        audioSetting,
+        videoSetting,
+        screenshareSetting,
+        chatSetting,
+        permissionConfig: parameters.permissionConfig,
+        participantLevel: islevel
+      });
+    } else {
+      response = 0;
+    }
+    switch (response) {
+      case 0:
+        checkScreenShare({ parameters });
+        break;
+      case 1: {
+        if (screenRequestState === "pending") {
+          showAlert?.({
+            message: "A request is already pending. Please wait for the host to respond.",
+            type: "danger",
+            duration: 3e3
+          });
+          return;
+        }
+        if (screenRequestState === "rejected" && Date.now() - screenRequestTime < updateRequestIntervalSeconds) {
+          showAlert?.({
+            message: "You cannot send another request at this time.",
+            type: "danger",
+            duration: 3e3
+          });
+          return;
+        }
+        showAlert?.({
+          message: "Your request has been sent to the host.",
+          type: "success",
+          duration: 3e3
+        });
+        screenRequestState = "pending";
+        updateScreenRequestState(screenRequestState);
+        const userRequest = { id: socket.id, name: member, icon: "fa-desktop" };
+        socket.emit("participantRequest", { userRequest, roomName });
+        break;
+      }
+      case 2:
+        showAlert?.({
+          message: "You are not allowed to start screen share.",
+          type: "danger",
+          duration: 3e3
+        });
+        break;
+    }
+  }
+};
+const timeLeftRecording = ({ timeLeft, showAlert }) => {
+  try {
+    showAlert?.({
+      message: `The recording will stop in less than ${timeLeft} seconds.`,
+      duration: 3e3,
+      type: "danger"
+    });
+  } catch (error) {
+    console.log("Error in timeLeftRecording: ", error);
+  }
+};
+const captureCanvasStream = async ({
+  parameters,
+  start = true
+}) => {
+  try {
+    let {
+      canvasWhiteboard,
+      canvasStream,
+      updateCanvasStream,
+      screenProducer,
+      localScreenProducer,
+      transportCreated,
+      localTransportCreated,
+      updateScreenProducer,
+      updateLocalScreenProducer,
+      localSocket,
+      sleep,
+      createSendTransport,
+      connectSendTransportScreen,
+      disconnectSendTransportScreen
+    } = parameters;
+    if (start && !canvasStream) {
+      const stream = canvasWhiteboard.captureStream(30);
+      canvasStream = stream;
+      updateCanvasStream(stream);
+      if (localSocket && !localSocket.id) {
+        try {
+          if (!localTransportCreated) {
+            await createSendTransport({ option: "screen", parameters });
+          } else {
+            try {
+              if (localScreenProducer) {
+                localScreenProducer.close();
+                if (updateLocalScreenProducer) {
+                  updateLocalScreenProducer(null);
+                }
+                await sleep({ ms: 500 });
+              }
+            } catch (error) {
+              console.error(error);
+            }
+            await connectSendTransportScreen({ stream, parameters });
+          }
+        } catch {
+        }
+        return;
+      }
+      if (!transportCreated) {
+        await createSendTransport({ option: "screen", parameters });
+      } else {
+        try {
+          if (screenProducer) {
+            screenProducer.close();
+            updateScreenProducer(null);
+            await sleep({ ms: 500 });
+          }
+        } catch (error) {
+          console.error(error);
+        }
+        await connectSendTransportScreen({ stream, parameters });
+      }
+    } else if (canvasStream && !start) {
+      canvasStream.getTracks().forEach((track) => track.stop());
+      canvasStream = null;
+      updateCanvasStream(null);
+      disconnectSendTransportScreen({ parameters });
+    }
+  } catch (error) {
+    console.error(error, "error in captureCanvasStream");
+  }
+};
+const QnHDCons = { width: { ideal: 320 }, height: { ideal: 180 } };
+const sdCons = { width: { ideal: 640 }, height: { ideal: 360 } };
+const hdCons = { width: { ideal: 1280 }, height: { ideal: 720 } };
+const fhdCons = { width: { ideal: 1920 }, height: { ideal: 1080 } };
+const qhdCons = { width: { ideal: 2560 }, height: { ideal: 1440 } };
+const QnHDConsPort = { width: { ideal: 180 }, height: { ideal: 320 } };
+const sdConsPort = { width: { ideal: 360 }, height: { ideal: 640 } };
+const hdConsPort = { width: { ideal: 720 }, height: { ideal: 1280 } };
+const fhdConsPort = { width: { ideal: 1080 }, height: { ideal: 1920 } };
+const qhdConsPort = { width: { ideal: 1440 }, height: { ideal: 2560 } };
+const QnHDConsNeu = { width: { ideal: 240 }, height: { ideal: 240 } };
+const sdConsNeu = { width: { ideal: 480 }, height: { ideal: 480 } };
+const hdConsNeu = { width: { ideal: 960 }, height: { ideal: 960 } };
+const fhdConsNeu = { width: { ideal: 1440 }, height: { ideal: 1440 } };
+const qhdConsNeu = { width: { ideal: 1920 }, height: { ideal: 1920 } };
+const QnHDFrameRate = 5;
+const sdFrameRate = 10;
+const hdFrameRate = 15;
+const fhdFrameRate = 20;
+const qhdFrameRate = 30;
+const screenFrameRate = 30;
+const hParams = {
+  encodings: [
+    {
+      rid: "r8",
+      maxBitrate: 24e4,
+      scalabilityMode: "L1T3",
+      scaleResolutionDownBy: 4
+    },
+    {
+      rid: "r9",
+      maxBitrate: 48e4,
+      scalabilityMode: "L1T3",
+      scaleResolutionDownBy: 2
+    },
+    {
+      rid: "r10",
+      maxBitrate: 96e4,
+      scalabilityMode: "L1T3"
+    }
+  ],
+  codecOptions: {
+    videoGoogleStartBitrate: 384
+  }
+};
+const vParams = {
+  encodings: [
+    {
+      rid: "r3",
+      maxBitrate: 2e5,
+      scalabilityMode: "L1T3",
+      scaleResolutionDownBy: 4
+    },
+    {
+      rid: "r4",
+      maxBitrate: 4e5,
+      scalabilityMode: "L1T3",
+      scaleResolutionDownBy: 2
+    },
+    {
+      rid: "r5",
+      maxBitrate: 8e5,
+      scalabilityMode: "L1T3"
+    }
+  ],
+  codecOptions: {
+    videoGoogleStartBitrate: 320
+  }
+};
+const screenParams = {
+  encodings: [
+    {
+      rid: "r7",
+      maxBitrate: 3e6
+    }
+  ],
+  codecOptions: {
+    videoGoogleStartBitrate: 1e3
+  }
+};
+const aParams = {
+  encodings: [
+    {
+      rid: "r0",
+      maxBitrate: 64e3
+    }
+  ]
+};
+const DEFAULT_MEDIA_SFU_ROOM_API_URL = "https://mediasfu.com/v1/rooms/";
+const getDefaultMediaSFURoomApiUrl = () => DEFAULT_MEDIA_SFU_ROOM_API_URL;
+const normalizeManagedRoomApi = (normalizedLink) => {
+  if (normalizedLink.includes("/v1/rooms")) {
+    return `${normalizedLink.replace(/\/$/, "")}/`;
+  }
+  return `${normalizedLink.replace(/\/$/, "")}/v1/rooms/`;
+};
+const resolveMediaSFURoomApi = (localLink, action) => {
+  const normalizedLink = localLink?.trim();
+  if (!normalizedLink) {
+    return getDefaultMediaSFURoomApiUrl();
+  }
+  if (normalizedLink.includes("mediasfu.com")) {
+    return normalizeManagedRoomApi(normalizedLink);
+  }
+  return `${normalizedLink.replace(/\/$/, "")}/${action}`;
+};
+const readResponseError = async (response) => {
+  const fallbackMessage = `HTTP error! Status: ${response.status}`;
+  try {
+    const responseText = await response.text();
+    if (!responseText) {
+      return fallbackMessage;
+    }
+    const parsedResponse = JSON.parse(responseText);
+    return parsedResponse.error || parsedResponse.message || responseText;
+  } catch {
+    return fallbackMessage;
+  }
+};
+const joinRoomOnMediaSFU = async ({
+  payload,
+  apiUserName,
+  apiKey,
+  localLink = ""
+}) => {
+  try {
+    if (!apiUserName || !apiKey || apiUserName === "yourAPIUSERNAME" || apiKey === "yourAPIKEY" || apiKey.length !== 64 || apiUserName.length < 6) {
+      return { data: { error: "Invalid credentials" }, success: false };
+    }
+    const finalLink = resolveMediaSFURoomApi(localLink, "joinRoom");
+    const response = await fetch(finalLink, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiUserName}:${apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(await readResponseError(response));
+    }
+    const data = await response.json();
+    return { data, success: true };
+  } catch (error) {
+    const errorMessage = error.reason || error.message || "unknown error";
+    return {
+      data: { error: `Unable to join room, ${errorMessage}` },
+      success: false
+    };
+  }
+};
+export {
+  QnHDFrameRate as A,
+  sdFrameRate as B,
+  hdFrameRate as C,
+  fhdFrameRate as D,
+  qhdFrameRate as E,
+  screenFrameRate as F,
+  resolveMediaSFURoomApi as G,
+  Cookies as H,
+  QnHDCons as Q,
+  checkLimitsAndMakeRequest as a,
+  clickAudio as b,
+  checkLimitsAndMakeRequestWithStorage as c,
+  clickScreenShare as d,
+  captureCanvasStream as e,
+  aParams as f,
+  hParams as g,
+  hostRequestResponse as h,
+  sdCons as i,
+  joinRoomOnMediaSFU as j,
+  hdCons as k,
+  fhdCons as l,
+  QnHDConsPort as m,
+  sdConsPort as n,
+  hdConsPort as o,
+  fhdConsPort as p,
+  qhdCons as q,
+  qhdConsPort as r,
+  screenParams as s,
+  timeLeftRecording as t,
+  QnHDConsNeu as u,
+  vParams as v,
+  sdConsNeu as w,
+  hdConsNeu as x,
+  fhdConsNeu as y,
+  qhdConsNeu as z
+};
+//# sourceMappingURL=joinRoomOnMediaSFU-y6vJ1OBo.js.map