@vkontakte/media-streaming 1.0.1-dev.7c4e0d2.0 → 1.0.1-dev.e965d10.0

package/{esnext.cjs → media-streaming.cjs}

@@ -1,6 +1,6 @@
 /**
- * @vkontakte/media-streaming v1.0.1-dev.7c4e0d2.0
- * Mon, 03 Aug 2026 09:18:14 GMT
+ * @vkontakte/media-streaming v1.0.1-dev.e965d10.0
+ * Mon, 03 Aug 2026 10:45:14 GMT
  */
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -61,7 +61,7 @@ __export(exports_src, {
 module.exports = __toCommonJS(exports_src);
 
 // src/env.ts
-var VERSION = "1.0.1-dev.7c4e0d2.0";
+var VERSION = "1.0.1-dev.e965d10.0";
 // src/constants.ts
 var DEFAULT_STUN_SERVERS = [{ urls: ["stun:videostun.mycdn.me:19302"] }];
 var DEFAULT_WS_SERVER = "wss://ovsu.mycdn.me/publish";
@@ -704,6 +704,6 @@ __legacyDecorateClassTS([
   WebRTCStreamer.notDestroying
 ], WebRTCStreamer.prototype, "destroy", null);
 
-//# debugId=F692A4354B910EA964756E2164756E21
+//# debugId=710FC6A0B6D5946064756E2164756E21
 
-//# sourceMappingURL=esnext.cjs.map
+//# sourceMappingURL=media-streaming.cjs.map

package/media-streaming.esm.js

@@ -0,0 +1,668 @@
+/**
+ * @vkontakte/media-streaming v1.0.1-dev.e965d10.0
+ * Mon, 03 Aug 2026 10:45:14 GMT
+ */
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/env.ts
+var VERSION = "1.0.1-dev.e965d10.0";
+// src/constants.ts
+var DEFAULT_STUN_SERVERS = [{ urls: ["stun:videostun.mycdn.me:19302"] }];
+var DEFAULT_WS_SERVER = "wss://ovsu.mycdn.me/publish";
+var WS_CLOSE_CODE = 1000;
+var DEFAULT_FRAME_RATE = 15;
+var SCREEN_SHARE_CONTENT_TEXTHINT = "text";
+var MediaErrorType;
+((MediaErrorType2) => {
+  MediaErrorType2["UNKNOWN"] = "unknown";
+  MediaErrorType2["ACCESS"] = "access";
+  MediaErrorType2["PERMISSION"] = "permission";
+  MediaErrorType2["DEVICES_NOT_FOUND"] = "devices_not_found";
+  MediaErrorType2["DEVICES_NOT_SUPPORTED"] = "devices_not_supported";
+})(MediaErrorType ||= {});
+var StreamerError;
+((StreamerError2) => {
+  StreamerError2["SOCKET"] = "socket";
+  StreamerError2["CONNECTION"] = "connection";
+  StreamerError2["NO_STREAM_DATA"] = "no_stream_data";
+  StreamerError2["PEERCONNECTION"] = "peerconnection";
+  StreamerError2["CONSTRAINTS"] = "constraints";
+})(StreamerError ||= {});
+// src/WebRTCStreamer.ts
+import { flattenObject } from "@vkontakte/videoplayer-shared";
+
+// src/MediaConstraints.ts
+class MediaConstraints {
+  config;
+  audio;
+  video;
+  constructor(config) {
+    this.config = config;
+    this.audio = false;
+    this.video = false;
+    const { audio, video } = this.config;
+    if (audio) {
+      const deviceId = typeof audio === "boolean" ? null : audio.deviceId;
+      this.audio = deviceId ? { deviceId: { exact: deviceId } } : true;
+    }
+    if (video) {
+      const videoConfig = typeof video === "boolean" ? {} : video;
+      const { minWidth, maxWidth, minHeight, maxHeight, aspectRatio, deviceId, facingMode } = videoConfig;
+      this.video = {
+        width: { min: minWidth, max: maxWidth || 3840, ideal: 1920 },
+        height: { min: minHeight, max: maxHeight || 2160, ideal: 1080 },
+        aspectRatio: { ideal: aspectRatio || 16 / 9 }
+      };
+      if (facingMode) {
+        this.video.facingMode = { exact: facingMode };
+      } else if (deviceId) {
+        this.video.deviceId = { exact: deviceId };
+      }
+    }
+  }
+  getNative() {
+    return Object.assign({}, { audio: this.audio, video: this.video });
+  }
+}
+
+// src/MediaError.ts
+class MediaError2 extends Error {
+  constructor(name, message) {
+    super(message);
+    this.name = name;
+  }
+}
+
+// src/utils.ts
+var getWindow = () => {
+  return globalThis;
+};
+var getSafariVersion = (userAgent) => {
+  const ua = userAgent ?? (typeof navigator !== "undefined" ? navigator.userAgent : "");
+  if (!ua) {
+    return;
+  }
+  const isSafari = /webkit/i.test(ua) && /safari/i.test(ua) && !/chrome|crios|chromium|yabrowser|samsungbrowser|opr\/|edg/i.test(ua);
+  if (!isSafari) {
+    return;
+  }
+  const versionMatch = ua.match(/Version\/(\d+)/);
+  if (!versionMatch) {
+    return;
+  }
+  const version = parseInt(versionMatch[1], 10);
+  return isNaN(version) ? undefined : version;
+};
+var enumerateDevices = async () => await getWindow().navigator.mediaDevices.enumerateDevices();
+var getUserMedia = (constraints) => getWindow().navigator.mediaDevices.getUserMedia(constraints).catch((e) => {
+  if (e instanceof Error) {
+    switch (e.name) {
+      case "PermissionDismissedError":
+      case "PermissionDeniedError":
+      case "SecurityError":
+      case "NotAllowedError":
+      case "DOMException":
+        throw new MediaError2(e.name, "permission" /* PERMISSION */);
+      case "OverconstrainedError":
+      case "NotFoundError":
+      case "TypeError":
+        throw new MediaError2(e.name, "unknown" /* UNKNOWN */);
+      case "AbortError":
+      case "NotReadableError":
+        throw new MediaError2(e.name, "access" /* ACCESS */);
+      default:
+        throw new MediaError2(e.name, "unknown" /* UNKNOWN */);
+    }
+  }
+  throw new Error("unknown");
+});
+var getDisplayMedia = (constraints) => getWindow().navigator.mediaDevices.getDisplayMedia(constraints.getNative()).catch((e) => {
+  if (e instanceof Error) {
+    switch (e.name) {
+      case "PermissionDeniedError":
+      case "SecurityError":
+      case "NotAllowedError":
+        throw new Error("permission");
+      default:
+        throw new Error("access");
+    }
+  }
+  throw new Error("unknown");
+});
+var omitKeys = (data, keys) => {
+  return Object.fromEntries(Object.entries(data).filter(([k]) => !keys.includes(k)));
+};
+var serializeTrack = (track) => {
+  return {
+    on: track.enabled,
+    k: track.kind,
+    ...track.contentHint && { h: track.contentHint }
+  };
+};
+var serializeStream = (stream) => {
+  return {
+    t: stream.getTracks().map(serializeTrack)
+  };
+};
+var serializeConfig = (cfg) => {
+  return {
+    key: cfg.streamKey,
+    ...cfg.audioOnly && { audioOnly: true },
+    ...cfg.lockOrientation && { lockOrientation: true },
+    ...cfg.mediaConstraints && { mediaConstraints: omitKeys(cfg.mediaConstraints, ["getNative"]) },
+    ...cfg.screenShare && { screenShare: omitKeys(cfg.screenShare, ["onEnded"]) }
+  };
+};
+var serializeMediaDevices = (devices) => {
+  return devices.map((d) => ({
+    id: d.deviceId.slice(0, 8),
+    kind: d.kind,
+    label: d.label
+  }));
+};
+
+// src/ScreenConstraints.ts
+class ScreenConstraints extends MediaConstraints {
+  constructor({ width, height, frameRate = DEFAULT_FRAME_RATE }) {
+    super({
+      video: true,
+      audio: false
+    });
+    if (typeof this.video === "object") {
+      delete this.video.deviceId;
+      delete this.video.aspectRatio;
+      delete this.video.frameRate;
+      delete this.video.facingMode;
+    } else {
+      this.video = {};
+    }
+    this.video.cursor = "motion";
+    this.video.width = width;
+    this.video.height = height;
+    this.video.frameRate = frameRate;
+    if (getSafariVersion() === 16) {
+      this.video.width = { max: width };
+      this.video.height = { max: height };
+    }
+  }
+}
+
+// src/WebRTCStreamer.ts
+class WebRTCStreamer {
+  config;
+  messagesQueue = [];
+  ws;
+  peerConnection;
+  stream;
+  screenShareTrack = null;
+  connected = false;
+  destroying = false;
+  cameraId;
+  microphoneId;
+  muted = false;
+  static notDestroying(_target, _propertyKey, descriptor) {
+    const original = descriptor.value;
+    descriptor.value = function(...args) {
+      if (this.destroying) {
+        return;
+      }
+      return original.apply(this, args);
+    };
+    return descriptor;
+  }
+  constructor(config) {
+    this.config = config;
+  }
+  callback(name, ...args) {
+    const fn = this.config.callbacks[name];
+    if (fn && !this.destroying) {
+      fn?.(...args);
+    }
+  }
+  async init() {
+    this.tracerLog("init", {
+      cfg: serializeConfig(this.config),
+      d: serializeMediaDevices(await enumerateDevices())
+    });
+    let permissionName = "user_media" /* USER_MEDIA */;
+    const { audioOnly, mediaConstraints, screenShare } = this.config;
+    try {
+      const constraints = mediaConstraints || new MediaConstraints({
+        audio: true,
+        video: !screenShare && !audioOnly
+      });
+      this.stream = await getUserMedia(constraints.getNative());
+      if (!audioOnly && screenShare) {
+        permissionName = "display_media" /* DISPLAY_MEDIA */;
+        const screenShareTrack = await this.createScreenShareStream(screenShare);
+        if (screenShareTrack) {
+          const { frameRate = DEFAULT_FRAME_RATE } = screenShare;
+          try {
+            await screenShareTrack.applyConstraints({
+              frameRate: { exact: frameRate }
+            });
+          } catch (e) {
+            this.tracerLog("error", { type: "constraints" /* CONSTRAINTS */ });
+            this.callback("onError", "constraints" /* CONSTRAINTS */);
+          }
+          this.stream.addTrack(screenShareTrack);
+        }
+        this.screenShareTrack = screenShareTrack;
+      }
+      this.tracerLog("streamChanged", serializeStream(this.stream));
+      this.callback("onStreamChanged", this.stream);
+    } catch (err) {
+      if (err instanceof MediaError) {
+        this.tracerLog("permissionFailed", { name: permissionName, msg: err.message, code: err.code });
+        this.callback("onPermissionFailed", permissionName, err);
+      } else {
+        this.tracerLog("permissionFailed", { name: permissionName });
+        this.callback("onPermissionFailed", permissionName);
+      }
+    }
+  }
+  async connect() {
+    this.tracerLog("connect");
+    this.openSocket();
+    if (!this.peerConnection) {
+      await this.createPeerConnection();
+    }
+  }
+  async switchCamera(deviceId) {
+    const { audioOnly } = this.config;
+    this.tracerLog("switchCamera", { id: deviceId, audioOnly });
+    if (audioOnly) {
+      return;
+    }
+    this.cameraId = deviceId;
+    const constraints = new MediaConstraints({
+      audio: this.microphoneId ? {
+        deviceId: this.microphoneId
+      } : true,
+      video: {
+        deviceId: this.cameraId
+      }
+    });
+    const newStream = await getUserMedia(constraints.getNative());
+    this.replaceStream(newStream);
+    if (this.muted) {
+      this.setMicMuted(true);
+    }
+  }
+  async switchMicrophone(deviceId) {
+    this.tracerLog("switchMicrophone", { id: deviceId });
+    this.microphoneId = deviceId;
+    const constraints = new MediaConstraints({
+      audio: {
+        deviceId: this.microphoneId
+      },
+      video: this.screenShareTrack ? false : this.cameraId ? {
+        deviceId: this.cameraId
+      } : true
+    });
+    const newStream = await getUserMedia(constraints.getNative());
+    if (this.screenShareTrack) {
+      newStream.addTrack(this.screenShareTrack);
+    }
+    this.replaceStream(newStream, true);
+    if (this.muted) {
+      this.setMicMuted(true);
+    }
+  }
+  async enableScreenShare(config) {
+    this.tracerLog("enableScreenShare", omitKeys(config, ["onEnded"]));
+    const constraints = new MediaConstraints({
+      audio: this.microphoneId ? { deviceId: this.microphoneId } : true,
+      video: false
+    });
+    const newStream = await getUserMedia(constraints.getNative());
+    const screenShareTrack = await this.createScreenShareStream(config);
+    if (screenShareTrack) {
+      const { frameRate = DEFAULT_FRAME_RATE } = config;
+      await screenShareTrack.applyConstraints({
+        frameRate: { exact: frameRate }
+      });
+      newStream.addTrack(screenShareTrack);
+    }
+    this.screenShareTrack = screenShareTrack;
+    this.replaceStream(newStream);
+    if (this.muted) {
+      this.setMicMuted(true);
+    }
+  }
+  async disableScreenShare(cameraDeviceId) {
+    this.tracerLog("disableScreenShare", cameraDeviceId ? { cid: cameraDeviceId } : undefined);
+    if (cameraDeviceId) {
+      await this.switchCamera(cameraDeviceId);
+    } else {
+      const devices = await enumerateDevices();
+      const defaultCamera = devices.find((d) => d.kind === "videoinput");
+      if (defaultCamera) {
+        await this.switchCamera(defaultCamera.deviceId);
+      }
+    }
+  }
+  setMicMuted(muted) {
+    this.tracerLog("setMicMuted", { m: muted });
+    this.muted = muted;
+    this.stream?.getAudioTracks().forEach((track) => {
+      track.enabled = !muted;
+    });
+  }
+  setCameraEnabled(enabled) {
+    this.tracerLog("setCameraEnabled", { on: enabled });
+    this.stream?.getVideoTracks().forEach((track) => {
+      track.enabled = enabled;
+    });
+  }
+  destroy() {
+    this.destroying = true;
+    this.tracerLog("destroy");
+    this.disconnect();
+    this.cameraId = undefined;
+    this.microphoneId = undefined;
+    this.muted = false;
+    if (this.stream) {
+      this.stream.getTracks().forEach((track) => track.stop());
+      this.stream = undefined;
+      this.screenShareTrack = null;
+    }
+  }
+  disconnect() {
+    this.tracerLog("disconnect");
+    this.closePeerConnection();
+    if (this.socketOpened) {
+      this.send({ type: "BYE" });
+      this.closeWSConnection();
+    }
+  }
+  replaceStream(stream, keepScreenShare = false) {
+    this.stream?.getTracks().forEach((track) => {
+      const isScreenShare = track.contentHint === SCREEN_SHARE_CONTENT_TEXTHINT;
+      if (!isScreenShare || !keepScreenShare) {
+        track.stop();
+        if (isScreenShare) {
+          this.screenShareTrack = null;
+        }
+      }
+      this.stream?.removeTrack(track);
+    });
+    this.stream = stream;
+    this.tracerLog("streamChanged", serializeStream(stream));
+    this.callback("onStreamChanged", this.stream);
+    this.replaceTracksInPeerConnection(this.stream);
+  }
+  replaceTracksInPeerConnection(stream, keepScreenShare = false) {
+    if (!this.peerConnection) {
+      return;
+    }
+    this.peerConnection.getTransceivers().forEach(({ sender }) => {
+      const { track } = sender;
+      if (track && (track.contentHint !== SCREEN_SHARE_CONTENT_TEXTHINT || !keepScreenShare)) {
+        track.stop();
+      }
+      stream.getTracks().forEach((newTrack) => {
+        if (track?.kind === newTrack.kind) {
+          sender.replaceTrack(newTrack).then(() => {}, () => {});
+        }
+      });
+    });
+  }
+  get socketOpened() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  async createScreenShareStream(screenShare) {
+    const { width, height, onEnded = null } = screenShare;
+    const displayStream = await getDisplayMedia(new ScreenConstraints({ width, height }));
+    const screenShareTrack = displayStream ? displayStream.getVideoTracks()[0] : null;
+    if (screenShareTrack) {
+      screenShareTrack.contentHint = SCREEN_SHARE_CONTENT_TEXTHINT;
+      screenShareTrack.onended = () => {
+        this.screenShareTrack = null;
+        onEnded?.();
+      };
+    }
+    return screenShareTrack;
+  }
+  openSocket() {
+    if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+      this.ws = new WebSocket(this.config.serverUrl ?? DEFAULT_WS_SERVER);
+      this.ws.onopen = this.handleWSOpen;
+      this.ws.onmessage = this.handleWSMessage;
+      this.ws.onclose = this.handleWSClose;
+    }
+  }
+  handleWSOpen = () => {
+    this.sendMessageFromQueue();
+  };
+  handleWSMessage = (event) => {
+    if (this.destroying || !this.ws || this.ws.readyState >= WebSocket.CLOSING) {
+      return;
+    }
+    const message = this.parseMessage(event.data);
+    switch (message.type) {
+      case "INVITE":
+        this.handleInviteMessage(message);
+        break;
+      case "ERROR":
+        this.handleError("socket" /* SOCKET */, message);
+        break;
+      case "STATUS":
+        this.handleStatusMessage(message);
+        break;
+    }
+  };
+  handleWSClose = (event) => {
+    this.closePeerConnection();
+    if (!this.ws) {
+      return;
+    }
+    this.messagesQueue = [];
+    this.connected = false;
+    this.ws = undefined;
+    this.tracerLog("disconnected", { code: event.code });
+    this.callback("onDisconnected", event);
+  };
+  send(message) {
+    this.messagesQueue.push(message);
+    if (this.socketOpened) {
+      this.sendMessageFromQueue();
+    }
+  }
+  sendMessageFromQueue() {
+    while (this.messagesQueue.length > 0) {
+      if (this.socketOpened) {
+        const message = this.messagesQueue.shift();
+        this.ws?.send(JSON.stringify(message));
+      }
+    }
+  }
+  handleStatusMessage(msg) {
+    const { status, message } = msg;
+    if (status === "INFO" && message === "no_stream_data") {
+      this.handleError("no_stream_data" /* NO_STREAM_DATA */, msg);
+    }
+  }
+  handleInviteMessage(message) {
+    switch (message.inviteType) {
+      case "ANSWER":
+        this.handleAnswer(message.sdp);
+        break;
+      case "CANDIDATE":
+        if (message.candidate) {
+          this.tracerLog("gotRTCCandidate", { v: message.candidate });
+          this.handleCandidate(message.candidate);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  handleAnswer(sdp) {
+    this.peerConnection?.setRemoteDescription(new RTCSessionDescription({ type: "answer", sdp }));
+  }
+  handleCandidate(candidate) {
+    this.peerConnection?.addIceCandidate(new RTCIceCandidate(candidate));
+  }
+  handleError(err, message) {
+    if (["no_stream_data" /* NO_STREAM_DATA */, "peerconnection" /* PEERCONNECTION */].includes(err)) {
+      this.closePeerConnection();
+      this.closeWSConnection();
+    }
+    const reason = message ? typeof message === "string" ? message : message.text ?? message.message : undefined;
+    this.tracerLog("error", { type: err, ...reason && { r: reason } });
+    this.callback("onError", err, reason);
+  }
+  async createPeerConnection() {
+    this.peerConnection = new RTCPeerConnection({
+      iceServers: this.config.stunServers ?? DEFAULT_STUN_SERVERS,
+      rtcpMuxPolicy: "require",
+      bundlePolicy: "max-compat"
+    });
+    this.peerConnection.onicecandidate = this.handleRTCIceCandidate;
+    this.peerConnection.onsignalingstatechange = this.handleRTCSignalingStateChange;
+    this.peerConnection.oniceconnectionstatechange = this.handleRTCIceConnectionStateChange;
+    this.stream?.getTracks().forEach((track) => {
+      if (track.kind === "video") {
+        track.contentHint = "text";
+      }
+      this.stream && this.peerConnection?.addTrack(track, this.stream);
+    });
+    try {
+      const offer = await this.peerConnection.createOffer();
+      if (this.config.lockOrientation) {
+        offer.sdp = offer.sdp?.replace(/a=extmap:[0-9]+ urn:3gpp:video-orientation[\r\n]+/g, "");
+      }
+      await this.setDescription(offer);
+    } catch (e) {
+      this.handleError("peerconnection" /* PEERCONNECTION */, "set offer description failed");
+    }
+  }
+  handleRTCIceCandidate = ({ candidate }) => {
+    if (candidate) {
+      this.tracerLog("sendRTCCandidate", { v: candidate.candidate });
+      this.send({
+        type: "INVITE",
+        promoCall: false,
+        inviteType: "CANDIDATE",
+        candidate
+      });
+    } else {
+      this.send({ type: "INVITE", promoCall: false, inviteType: "CANDIDATE" });
+    }
+  };
+  handleRTCSignalingStateChange = () => {
+    if (!this.peerConnection) {
+      return;
+    }
+    switch (this.peerConnection.signalingState) {
+      case "have-local-offer":
+        const sdp = this.peerConnection.localDescription?.sdp;
+        this.send({
+          type: "INVITE",
+          inviteType: "OFFER",
+          promoCall: false,
+          streamKey: this.config.streamKey,
+          sdp
+        });
+        break;
+      case "closed":
+        this.handleError("peerconnection" /* PEERCONNECTION */, "signalling closed");
+        break;
+    }
+  };
+  handleRTCIceConnectionStateChange = () => {
+    if (!this.peerConnection) {
+      return;
+    }
+    switch (this.peerConnection.iceConnectionState) {
+      case "failed":
+        this.handleError("peerconnection" /* PEERCONNECTION */, "ice connection failed");
+        break;
+      case "disconnected":
+        this.disconnect();
+        break;
+      case "connected":
+        this.connected = true;
+        this.tracerLog("connected");
+        this.callback("onConnected");
+        break;
+    }
+  };
+  async setDescription(description) {
+    try {
+      await this.peerConnection?.setLocalDescription(description);
+    } catch (e) {
+      this.handleError("peerconnection" /* PEERCONNECTION */, "set local description failed");
+    }
+  }
+  closePeerConnection() {
+    if (this.peerConnection) {
+      if (this.peerConnection.signalingState !== "closed") {
+        this.peerConnection.close();
+      }
+      this.peerConnection = undefined;
+    }
+  }
+  closeWSConnection() {
+    if (this.ws && this.ws.readyState < WebSocket.CLOSING) {
+      this.ws.close(WS_CLOSE_CODE);
+    }
+  }
+  parseMessage(data) {
+    try {
+      return JSON.parse(data);
+    } catch (e) {
+      return { type: "EMPTY" };
+    }
+  }
+  tracerLog(event, data) {
+    return this.config.tracer?.log(event, flattenObject(data));
+  }
+}
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "init", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "connect", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "switchCamera", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "switchMicrophone", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "enableScreenShare", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "disableScreenShare", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "setMicMuted", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "setCameraEnabled", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "destroy", null);
+export {
+  WebRTCStreamer,
+  VERSION,
+  StreamerError,
+  MediaErrorType
+};
+
+//# debugId=281C5760B351F83D64756E2164756E21
+
+//# sourceMappingURL=media-streaming.esm.js.map

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@vkontakte/media-streaming",
-  "version": "1.0.1-dev.7c4e0d2.0",
+  "version": "1.0.1-dev.e965d10.0",
   "author": "vk.com",
   "description": "VK WebRTC media streaming module",
   "homepage": "https://vk.com",
   "license": "GPL-3.0",
-  "main": "esnext.cjs",
-  "module": "esnext.esm.js",
+  "main": "media-streaming.cjs",
+  "module": "media-streaming.esm.js",
   "types": "types/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./out/types/index.d.ts",
-      "import": "./out/esnext.esm.js",
-      "require": "./out/esnext.cjs"
+      "types": "./types/index.d.ts",
+      "import": "./media-streaming.esm.js",
+      "require": "./media-streaming.cjs"
     }
   },
   "files": [
-    "out/esnext.esm.js",
-    "out/esnext.cjs",
-    "out/types/**/*.d.ts"
+    "media-streaming.esm.js",
+    "media-streaming.cjs",
+    "types/**/*.d.ts"
   ],
   "dependencies": {
     "@vkontakte/videoplayer-shared": "^1.0.97"

package/types/MediaConstraints.d.ts

@@ -0,0 +1,8 @@
+import type { IMediaConstraints, MediaConstraintsConfig } from "./types";
+export declare class MediaConstraints implements IMediaConstraints {
+	protected readonly config: MediaConstraintsConfig;
+	audio: boolean | MediaTrackConstraints;
+	video: boolean | MediaTrackConstraints;
+	constructor(config: MediaConstraintsConfig);
+	getNative(): MediaStreamConstraints;
+}

package/types/MediaError.d.ts

@@ -0,0 +1,4 @@
+import type { MediaErrorType } from "./constants";
+export declare class MediaError extends Error {
+	constructor(name: string, message: MediaErrorType);
+}

package/types/ScreenConstraints.d.ts

@@ -0,0 +1,5 @@
+import { MediaConstraints } from "./MediaConstraints";
+import type { ScreenConstraintsConfig } from "./types";
+export declare class ScreenConstraints extends MediaConstraints {
+	constructor({ width, height, frameRate }: ScreenConstraintsConfig);
+}

package/types/WebRTCStreamer.d.ts

@@ -0,0 +1,51 @@
+import type { ScreenShareConfig, WebRTCStreamerConfig } from "./types";
+export declare class WebRTCStreamer {
+	private readonly config;
+	private messagesQueue;
+	private ws;
+	private peerConnection;
+	private stream;
+	private screenShareTrack;
+	private connected;
+	private destroying;
+	private cameraId;
+	private microphoneId;
+	private muted;
+	private static notDestroying;
+	constructor(config: WebRTCStreamerConfig);
+	private callback;
+	init(): Promise<void>;
+	connect(): Promise<void>;
+	switchCamera(deviceId: string): Promise<void>;
+	switchMicrophone(deviceId: string): Promise<void>;
+	enableScreenShare(config: ScreenShareConfig): Promise<void>;
+	disableScreenShare(cameraDeviceId?: string): Promise<void>;
+	setMicMuted(muted: boolean): void;
+	setCameraEnabled(enabled: boolean): void;
+	destroy(): void;
+	private disconnect;
+	private replaceStream;
+	private replaceTracksInPeerConnection;
+	private get socketOpened();
+	private createScreenShareStream;
+	private openSocket;
+	private readonly handleWSOpen;
+	private readonly handleWSMessage;
+	private readonly handleWSClose;
+	private send;
+	private sendMessageFromQueue;
+	private handleStatusMessage;
+	private handleInviteMessage;
+	private handleAnswer;
+	private handleCandidate;
+	private handleError;
+	private createPeerConnection;
+	private readonly handleRTCIceCandidate;
+	private readonly handleRTCSignalingStateChange;
+	private readonly handleRTCIceConnectionStateChange;
+	private setDescription;
+	private closePeerConnection;
+	private closeWSConnection;
+	private parseMessage;
+	private tracerLog;
+}

package/types/constants.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_STUN_SERVERS: RTCIceServer[];
+export declare const DEFAULT_WS_SERVER = "wss://ovsu.mycdn.me/publish";
+export declare const WS_CLOSE_CODE = 1e3;
+export declare const DEFAULT_FRAME_RATE = 15;
+export declare const SCREEN_SHARE_CONTENT_TEXTHINT = "text";
+export declare enum PermissionName {
+	DISPLAY_MEDIA = "display_media",
+	USER_MEDIA = "user_media"
+}
+export declare enum MediaErrorType {
+	UNKNOWN = "unknown",
+	ACCESS = "access",
+	PERMISSION = "permission",
+	DEVICES_NOT_FOUND = "devices_not_found",
+	DEVICES_NOT_SUPPORTED = "devices_not_supported"
+}
+export declare enum StreamerError {
+	SOCKET = "socket",
+	CONNECTION = "connection",
+	NO_STREAM_DATA = "no_stream_data",
+	PEERCONNECTION = "peerconnection",
+	CONSTRAINTS = "constraints"
+}
+export declare enum StreamerEvent {
+	ERROR = "error",
+	PERMISSION = "permission",
+	CONNECT = "connect",
+	DISCONNECT = "disconnect",
+	CONNECTING = "connecting",
+	DESTROY = "destroy"
+}

package/types/env.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export { VERSION } from "./env";
+export type { IMediaConstraints, ScreenShareConfig, WebRTCStreamerConfig, WebRTCStreamerCallbacks } from "./types";
+export { MediaErrorType, StreamerError } from "./constants";
+export { WebRTCStreamer } from "./WebRTCStreamer";

package/types/types.d.ts

@@ -0,0 +1,66 @@
+import type { ITracer } from "@vkontakte/videoplayer-shared";
+import type { PermissionName, StreamerError } from "./constants";
+export type SafeAny = any;
+export type RTCMessageType = "INVITE" | "STATUS" | "BYE" | "ERROR" | "EMPTY";
+export type RTCMessageInviteType = "OFFER" | "CANDIDATE" | "ANSWER" | "BYE";
+export interface RTCMessage {
+	type: RTCMessageType;
+	inviteType?: RTCMessageInviteType;
+	streamKey?: string;
+	sdp?: string;
+	status?: string;
+	message?: string;
+	text?: string;
+	candidate?: RTCIceCandidateInit;
+	promoCall?: boolean;
+}
+export interface WSIncomingMessage {
+	data: string;
+}
+export interface MediaDeviceConfig {
+	deviceId?: string;
+}
+export interface VideoMediaConfig extends MediaDeviceConfig {
+	minWidth?: number;
+	maxWidth?: number;
+	minHeight?: number;
+	maxHeight?: number;
+	aspectRatio?: number;
+	facingMode?: "user" | "environment";
+}
+export interface MediaConstraintsConfig {
+	audio: boolean | MediaDeviceConfig;
+	video: boolean | VideoMediaConfig;
+}
+export interface ScreenConstraintsConfig {
+	width: number;
+	height: number;
+	frameRate?: number;
+}
+export interface IMediaConstraints {
+	audio: boolean | MediaTrackConstraints;
+	video: boolean | MediaTrackConstraints;
+	getNative(): MediaStreamConstraints;
+}
+export interface WebRTCStreamerCallbacks {
+	onConnected?: VoidFunction;
+	onDisconnected?: (event: CloseEvent) => void;
+	onError?: (err: StreamerError, reason?: string) => void;
+	onPermissionFailed?: (permissionName: PermissionName, err?: MediaError) => void;
+	onStreamChanged?: (stream: MediaStream | undefined) => void;
+}
+export type CallbackArgs<N extends keyof WebRTCStreamerCallbacks> = Parameters<NonNullable<WebRTCStreamerCallbacks[N]>>;
+export type ScreenShareConfig = ScreenConstraintsConfig & {
+	onEnded?: VoidFunction;
+};
+export interface WebRTCStreamerConfig {
+	streamKey: string;
+	callbacks: WebRTCStreamerCallbacks;
+	audioOnly?: boolean;
+	lockOrientation?: boolean;
+	mediaConstraints?: IMediaConstraints;
+	screenShare?: ScreenShareConfig;
+	serverUrl?: string;
+	stunServers?: RTCIceServer[];
+	tracer?: ITracer;
+}

package/types/utils.d.ts

@@ -0,0 +1,19 @@
+import type { SafeAny } from "./types";
+import type { ScreenConstraints } from "./ScreenConstraints";
+import type { WebRTCStreamerConfig } from "./types";
+/**
+* Определяет версию Safari по userAgent.
+* Возвращает major-версию как число, либо undefined если браузер не Safari
+* или версию не удалось определить.
+*
+* @param userAgent — строка user-agent (по умолчанию navigator.userAgent)
+* @returns номер major-версии Safari или undefined
+*/
+export declare const getSafariVersion: (userAgent?: string) => number | undefined;
+export declare const enumerateDevices: () => Promise<MediaDeviceInfo[]>;
+export declare const getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+export declare const getDisplayMedia: (constraints: ScreenConstraints) => Promise<MediaStream>;
+export declare const omitKeys: <T extends Record<string, SafeAny>>(data: T, keys: (keyof T)[]) => Record<string, SafeAny>;
+export declare const serializeStream: (stream: MediaStream) => Record<string, SafeAny>;
+export declare const serializeConfig: (cfg: WebRTCStreamerConfig) => Record<string, SafeAny>;
+export declare const serializeMediaDevices: (devices: MediaDeviceInfo[]) => Record<string, SafeAny>[];