@vkontakte/media-streaming 1.0.1-dev.2e8c6c4.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@vkontakte/media-streaming",
+  "version": "1.0.1-dev.2e8c6c4.0",
+  "author": "vk.com",
+  "description": "VK WebRTC media streaming module",
+  "homepage": "https://vk.com",
+  "license": "GPL-3.0",
+  "main": "media-streaming.cjs",
+  "module": "media-streaming.esm.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./media-streaming.esm.js",
+      "require": "./media-streaming.cjs"
+    }
+  },
+  "files": [
+    "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 { MediaConstraintsConfig } from "./types";
+export declare class MediaConstraints {
+	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 StreamerMediaError 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,50 @@
+import type { ScreenShareConfig, WebRTCStreamerConfig } from "./types";
+export declare class WebRTCStreamer {
+	#private;
+	private readonly config;
+	private static notDestroying;
+	constructor(config: WebRTCStreamerConfig);
+	private callback;
+	get connected(): boolean;
+	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>;
+	switchMediaDevices({ cameraId, microphoneId, screenShare }: {
+		cameraId?: string | false;
+		microphoneId?: string | false;
+		screenShare?: ScreenShareConfig | false;
+	}): 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 handleScreenShareConstraintsError;
+	private handleError;
+	private createPeerConnection;
+	private readonly handleRTCIceCandidate;
+	private readonly handleRTCSignalingStateChange;
+	private readonly handleRTCIceConnectionStateChange;
+	private setDescription;
+	private closePeerConnection;
+	private closeWSConnection;
+	private parseMessage;
+	private tracerLog;
+	private logStat;
+}

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,12 @@
+import type { MediaConstraintsConfig } from "./types";
+export { VERSION } from "./env";
+export type { MediaConstraintsConfig, ScreenShareConfig, StatisticsData, IStatisticsLogger, WebRTCStreamerConfig, WebRTCStreamerCallbacks } from "./types";
+export { MediaErrorType, StreamerError, PermissionName } from "./constants";
+export declare const MediaUtils: {
+	enumerateDevices: () => Promise<{
+		cameras: MediaDeviceInfo[];
+		microphones: MediaDeviceInfo[];
+	}>;
+	getUserStream: (config: MediaConstraintsConfig) => Promise<MediaStream>;
+};
+export { WebRTCStreamer } from "./WebRTCStreamer";

package/types/types.d.ts

@@ -0,0 +1,71 @@
+import type { ITracer } from "@vkontakte/videoplayer-shared";
+import type { PermissionName, StreamerError } from "./constants";
+import type { StreamerMediaError } from "./MediaError";
+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 WebRTCStreamerCallbacks {
+	onConnecting?: VoidFunction;
+	onConnected?: VoidFunction;
+	onDisconnected?: (event: CloseEvent) => void;
+	onError?: (err: StreamerError, reason?: string) => void;
+	onPermissionFailed?: (permissionName: PermissionName, err?: StreamerMediaError) => void;
+	onStreamChanged?: (stream: MediaStream | undefined) => void;
+}
+export type CallbackArgs<N extends keyof WebRTCStreamerCallbacks> = Parameters<NonNullable<WebRTCStreamerCallbacks[N]>>;
+export type ScreenShareConfig = ScreenConstraintsConfig & {
+	onEnded?: VoidFunction;
+};
+type StatDataValue = number | string;
+type StatDataArrValue = StatDataValue[];
+export type StatisticsData = StatDataValue | StatDataArrValue | Record<string, StatDataValue | StatDataArrValue>;
+export interface IStatisticsLogger {
+	log: (event: string, data: StatisticsData) => void;
+}
+export interface WebRTCStreamerConfig {
+	streamKey: string;
+	callbacks: WebRTCStreamerCallbacks;
+	audioOnly?: boolean;
+	lockOrientation?: boolean;
+	mediaConfig?: MediaConstraintsConfig;
+	screenShare?: ScreenShareConfig;
+	serverUrl?: string;
+	stunServers?: RTCIceServer[];
+	statisticsLogger?: IStatisticsLogger;
+	tracer?: ITracer;
+}
+export {};

package/types/utils.d.ts

@@ -0,0 +1,22 @@
+import type { MediaConstraintsConfig, 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<{
+	cameras: MediaDeviceInfo[];
+	microphones: MediaDeviceInfo[];
+}>;
+export declare const getUserStream: (config: MediaConstraintsConfig) => 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>[];