mediasfu-shared 1.0.1 → 1.0.3

package/package.json

@@ -1,78 +1,96 @@
-{
-  "name": "mediasfu-shared",
-  "version": "1.0.1",
-  "description": "Framework-agnostic shared logic for MediaSFU - works with React, Vue, Angular, Svelte, and any JavaScript framework",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./consumers": {
-      "types": "./dist/consumers/index.d.ts",
-      "import": "./dist/consumers/index.js",
-      "require": "./dist/consumers/index.cjs"
-    },
-    "./methods": {
-      "types": "./dist/methods/index.d.ts",
-      "import": "./dist/methods/index.js",
-      "require": "./dist/methods/index.cjs"
-    },
-    "./types": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/types/index.js",
-      "require": "./dist/types/index.cjs"
-    }
-  },
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc && vite build",
-    "dev": "vite build --watch",
-    "type-check": "tsc --noEmit"
-  },
-  "keywords": [
-    "mediasfu",
-    "shared",
-    "webrtc",
-    "video-conferencing",
-    "breakout-rooms",
-    "screen-sharing",
-    "recording",
-    "framework-agnostic",
-    "typescript"
-  ],
-  "author": "MediaSFU",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/MediaSFU/MediaSFU-Shared"
-  },
-  "homepage": "https://github.com/MediaSFU/MediaSFU-Shared",
-  "bugs": {
-    "url": "https://github.com/MediaSFU/MediaSFU-Shared/issues",
-    "email": "info@mediasfu.com"
-  },
-  "peerDependencies": {
-    "mediasoup-client": "^3.16.0",
-    "socket.io-client": "^4.8.0"
-  },
-  "dependencies": {
-    "universal-cookie": "^7.2.2"
-  },
-  "devDependencies": {
-    "mediasoup-client": "^3.16.0",
-    "socket.io-client": "^4.8.0",
-    "typescript": "^5.9.3",
-    "vite": "^7.1.9",
-    "vite-plugin-dts": "^4.3.0"
-  }
-}
+{
+  "name": "mediasfu-shared",
+  "version": "1.0.3",
+  "description": "Framework-agnostic MediaSFU WebRTC runtime for room creation, joining, mediasoup signaling, sockets, media state, translation, and reusable SDK types",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./consumers": {
+      "types": "./dist/consumers/index.d.ts",
+      "import": "./dist/consumers/index.js",
+      "require": "./dist/consumers/index.cjs"
+    },
+    "./methods": {
+      "types": "./dist/methods/index.d.ts",
+      "import": "./dist/methods/index.js",
+      "require": "./dist/methods/index.cjs"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "require": "./dist/types/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && vite build",
+    "build-docs": "typedoc",
+    "dev": "vite build --watch",
+    "test:staging:smoke": "npm run build && node ./scripts/staging-room-smoke-test.cjs",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "mediasfu",
+    "webrtc",
+    "webRTC",
+    "mediasoup",
+    "sfu",
+    "video-conferencing",
+    "video-call",
+    "audio-call",
+    "socket.io",
+    "real-time-communication",
+    "real-time-media",
+    "room-management",
+    "screen-sharing",
+    "recording",
+    "live-streaming",
+    "webinar",
+    "broadcasting",
+    "whiteboard",
+    "live-subtitles",
+    "translation",
+    "framework-agnostic",
+    "typescript",
+    "mediasfu-shared"
+  ],
+  "author": "MediaSFU",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MediaSFU/MediaSFU-Shared"
+  },
+  "homepage": "https://github.com/MediaSFU/MediaSFU-Shared",
+  "bugs": {
+    "url": "https://github.com/MediaSFU/MediaSFU-Shared/issues",
+    "email": "info@mediasfu.com"
+  },
+  "peerDependencies": {
+    "mediasoup-client": "^3.16.0",
+    "socket.io-client": "^4.8.0"
+  },
+  "dependencies": {
+    "universal-cookie": "^7.2.2"
+  },
+  "devDependencies": {
+    "mediasoup-client": "^3.16.0",
+    "socket.io-client": "^4.8.0",
+    "typedoc": "^0.28.14",
+    "typedoc-plugin-extras": "^4.0.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.9",
+    "vite-plugin-dts": "^4.3.0"
+  }
+}

package/src/ProducerClient/producerClientEmits/joinRoomClient.ts

@@ -0,0 +1,57 @@
+import { Socket } from 'socket.io-client';
+import { joinRoom, JoinRoomResponse } from '../../producers/producerEmits/joinRoom';
+import { joinConRoom, JoinConRoomResponse } from '../../producers/producerEmits/joinConRoom';
+
+export interface JoinRoomClientOptions {
+  socket: Socket;
+  roomName: string;
+  islevel: string;
+  member: string;
+  sec: string;
+  apiUserName: string;
+  consume?: boolean;
+}
+
+export type JoinRoomClientResponse = JoinRoomResponse | JoinConRoomResponse;
+export type JoinRoomClientType = (options: JoinRoomClientOptions) => Promise<JoinRoomClientResponse>;
+
+/**
+ * Joins a room by delegating to the producer or consumer join emit based on the consume flag.
+ *
+ * @param {JoinRoomClientOptions} options - The options for joining the room.
+ * @returns {Promise<JoinRoomClientResponse>} The response returned from the server.
+ */
+export const joinRoomClient = async ({
+  socket,
+  roomName,
+  islevel,
+  member,
+  sec,
+  apiUserName,
+  consume = false,
+}: JoinRoomClientOptions): Promise<JoinRoomClientResponse> => {
+  try {
+    if (consume) {
+      return await joinConRoom({
+        socket,
+        roomName,
+        islevel,
+        member,
+        sec,
+        apiUserName,
+      });
+    }
+
+    return await joinRoom({
+      socket,
+      roomName,
+      islevel,
+      member,
+      sec,
+      apiUserName,
+    });
+  } catch (error) {
+    console.log(error);
+    throw new Error('Failed to join the room. Please check your connection and try again.');
+  }
+};

package/src/ProducerClient/producerClientEmits/updateRoomParametersClient.ts

@@ -0,0 +1,401 @@
+/* eslint-disable eqeqeq */
+import { RtpCapabilities } from 'mediasoup-client/lib/types';
+import {
+  QnHDCons,
+  sdCons,
+  hdCons,
+  fhdCons,
+  qhdCons,
+  QnHDConsPort,
+  sdConsPort,
+  hdConsPort,
+  fhdConsPort,
+  qhdConsPort,
+  QnHDConsNeu,
+  sdConsNeu,
+  hdConsNeu,
+  fhdConsNeu,
+  qhdConsNeu,
+  QnHDFrameRate,
+  hdFrameRate,
+  fhdFrameRate,
+  qhdFrameRate,
+} from '../../methods/utils/producer/videoCaptureConstraints';
+import { hParams as host_Params } from '../../methods/utils/producer/hParams';
+import { vParams as video_Params } from '../../methods/utils/producer/vParams';
+import { screenParams as screen_Params } from '../../methods/utils/producer/screenParams';
+import { aParams as audio_Params } from '../../methods/utils/producer/aParams';
+import {
+  HParamsType,
+  VParamsType,
+  ScreenParamsType,
+  AParamsType,
+  MeetingRoomParams,
+  VidCons,
+  ShowAlert,
+  ResponseJoinRoom,
+  EventType,
+} from '../../types/shared-base-types';
+
+export interface UpdateRoomParametersClientParameters {
+  rtpCapabilities: RtpCapabilities | null;
+  roomRecvIPs: string[];
+  meetingRoomParams: MeetingRoomParams | null;
+  itemPageLimit: number;
+  audioOnlyRoom: boolean;
+  addForBasic: boolean;
+  screenPageLimit: number;
+  shareScreenStarted: boolean;
+  shared: boolean;
+  targetOrientation: string;
+  vidCons: VidCons;
+  recordingVideoSupport: boolean;
+  frameRate: number;
+  adminPasscode: string;
+  eventType: EventType;
+  youAreCoHost: boolean;
+  autoWave: boolean;
+  forceFullDisplay: boolean;
+  chatSetting: string;
+  meetingDisplayType: string;
+  audioSetting: string;
+  videoSetting: string;
+  screenshareSetting: string;
+  hParams: HParamsType;
+  vParams: VParamsType;
+  screenParams: ScreenParamsType;
+  aParams: AParamsType;
+  islevel: string;
+  showAlert?: ShowAlert;
+  data: ResponseJoinRoom;
+  updateRtpCapabilities: (rtpCapabilities: RtpCapabilities | null) => void;
+  updateRoomRecvIPs: (roomRecvIPs: string[]) => void;
+  updateMeetingRoomParams: (meetingRoomParams: MeetingRoomParams | null) => void;
+  updateItemPageLimit: (limit: number) => void;
+  updateAudioOnlyRoom: (isAudioOnly: boolean) => void;
+  updateAddForBasic: (addForBasic: boolean) => void;
+  updateScreenPageLimit: (limit: number) => void;
+  updateVidCons: (cons: VidCons) => void;
+  updateFrameRate: (frameRate: number) => void;
+  updateAdminPasscode: (passcode: string) => void;
+  updateEventType: (eventType: EventType) => void;
+  updateYouAreCoHost: (coHost: boolean) => void;
+  updateAutoWave: (autoWave: boolean) => void;
+  updateForceFullDisplay: (forceFull: boolean) => void;
+  updateChatSetting: (setting: string) => void;
+  updateMeetingDisplayType: (type: string) => void;
+  updateAudioSetting: (setting: string) => void;
+  updateVideoSetting: (setting: string) => void;
+  updateScreenshareSetting: (setting: string) => void;
+  updateHParams: (params: HParamsType) => void;
+  updateVParams: (params: VParamsType) => void;
+  updateScreenParams: (params: ScreenParamsType) => void;
+  updateAParams: (params: AParamsType) => void;
+  updateMainHeightWidth: (heightWidth: number) => void;
+  updateTargetResolution: (resolution: string) => void;
+  updateTargetResolutionHost: (resolution: string) => void;
+  updateRecordingAudioPausesLimit: (limit: number) => void;
+  updateRecordingAudioPausesCount: (count: number) => void;
+  updateRecordingAudioSupport: (support: boolean) => void;
+  updateRecordingAudioPeopleLimit: (limit: number) => void;
+  updateRecordingAudioParticipantsTimeLimit: (limit: number) => void;
+  updateRecordingVideoPausesCount: (count: number) => void;
+  updateRecordingVideoPausesLimit: (limit: number) => void;
+  updateRecordingVideoSupport: (support: boolean) => void;
+  updateRecordingVideoPeopleLimit: (limit: number) => void;
+  updateRecordingVideoParticipantsTimeLimit: (limit: number) => void;
+  updateRecordingAllParticipantsSupport: (support: boolean) => void;
+  updateRecordingVideoParticipantsSupport: (support: boolean) => void;
+  updateRecordingAllParticipantsFullRoomSupport: (support: boolean) => void;
+  updateRecordingVideoParticipantsFullRoomSupport: (support: boolean) => void;
+  updateRecordingPreferredOrientation: (orientation: string) => void;
+  updateRecordingSupportForOtherOrientation: (support: boolean) => void;
+  updateRecordingMultiFormatsSupport: (support: boolean) => void;
+  updateRecordingVideoOptions: (options: string) => void;
+  updateRecordingAudioOptions: (options: string) => void;
+}
+
+export type UpdateRoomParametersClientOptions = {
+  parameters: UpdateRoomParametersClientParameters;
+};
+
+export type UpdateRoomParametersClientType = (options: UpdateRoomParametersClientOptions) => void;
+
+export const updateRoomParametersClient = ({ parameters }: UpdateRoomParametersClientOptions): void => {
+  try {
+    const {
+      screenPageLimit,
+      shareScreenStarted,
+      shared,
+      hParams = host_Params,
+      vParams = video_Params,
+      frameRate,
+      islevel,
+      showAlert,
+      data,
+      updateRtpCapabilities,
+      updateRoomRecvIPs,
+      updateMeetingRoomParams,
+      updateItemPageLimit,
+      updateAudioOnlyRoom,
+      updateScreenPageLimit,
+      updateVidCons,
+      updateFrameRate,
+      updateAdminPasscode,
+      updateEventType,
+      updateYouAreCoHost,
+      updateAutoWave,
+      updateForceFullDisplay,
+      updateChatSetting,
+      updateMeetingDisplayType,
+      updateAudioSetting,
+      updateVideoSetting,
+      updateScreenshareSetting,
+      updateHParams,
+      updateVParams,
+      updateScreenParams,
+      updateAParams,
+      updateTargetResolution,
+      updateTargetResolutionHost,
+      updateRecordingAudioPausesLimit,
+      updateRecordingAudioPausesCount,
+      updateRecordingAudioSupport,
+      updateRecordingAudioPeopleLimit,
+      updateRecordingAudioParticipantsTimeLimit,
+      updateRecordingVideoPausesCount,
+      updateRecordingVideoPausesLimit,
+      updateRecordingVideoSupport,
+      updateRecordingVideoPeopleLimit,
+      updateRecordingVideoParticipantsTimeLimit,
+      updateRecordingAllParticipantsSupport,
+      updateRecordingVideoParticipantsSupport,
+      updateRecordingAllParticipantsFullRoomSupport,
+      updateRecordingVideoParticipantsFullRoomSupport,
+      updateRecordingPreferredOrientation,
+      updateRecordingSupportForOtherOrientation,
+      updateRecordingMultiFormatsSupport,
+      updateRecordingVideoOptions,
+      updateRecordingAudioOptions,
+      updateMainHeightWidth,
+    } = parameters;
+
+    if (data.rtpCapabilities == null) {
+      const reason = data.reason || '';
+      showAlert?.({
+        message: `Sorry, you are not allowed to join this room. ${reason}`,
+        type: 'danger',
+        duration: 3000,
+      });
+      return;
+    }
+
+    updateRtpCapabilities(data.rtpCapabilities);
+    updateAdminPasscode(data.secureCode);
+    updateRoomRecvIPs(data.roomRecvIPs);
+    updateMeetingRoomParams(data.meetingRoomParams);
+
+    updateRecordingAudioPausesLimit(data.recordingParams.recordingAudioPausesLimit);
+    updateRecordingAudioPausesCount(data.recordingParams.recordingAudioPausesCount!);
+    updateRecordingAudioSupport(data.recordingParams.recordingAudioSupport);
+    updateRecordingAudioPeopleLimit(data.recordingParams.recordingAudioPeopleLimit);
+    updateRecordingAudioParticipantsTimeLimit(data.recordingParams.recordingAudioParticipantsTimeLimit);
+    updateRecordingVideoPausesCount(data.recordingParams.recordingVideoPausesCount!);
+    updateRecordingVideoPausesLimit(data.recordingParams.recordingVideoPausesLimit);
+    updateRecordingVideoSupport(data.recordingParams.recordingVideoSupport);
+    updateRecordingVideoPeopleLimit(data.recordingParams.recordingVideoPeopleLimit);
+    updateRecordingVideoParticipantsTimeLimit(data.recordingParams.recordingVideoParticipantsTimeLimit);
+    updateRecordingAllParticipantsSupport(data.recordingParams.recordingAllParticipantsSupport);
+    updateRecordingVideoParticipantsSupport(data.recordingParams.recordingVideoParticipantsSupport);
+    updateRecordingAllParticipantsFullRoomSupport(data.recordingParams.recordingAllParticipantsFullRoomSupport);
+    updateRecordingVideoParticipantsFullRoomSupport(data.recordingParams.recordingVideoParticipantsFullRoomSupport);
+    updateRecordingPreferredOrientation(data.recordingParams.recordingPreferredOrientation);
+    updateRecordingSupportForOtherOrientation(data.recordingParams.recordingSupportForOtherOrientation);
+    updateRecordingMultiFormatsSupport(data.recordingParams.recordingMultiFormatsSupport);
+
+    updateItemPageLimit(data.meetingRoomParams.itemPageLimit);
+    updateEventType(data.meetingRoomParams.type);
+
+    if (data.meetingRoomParams.type == 'chat' && islevel != '2') {
+      updateYouAreCoHost(true);
+    }
+
+    if (['chat', 'broadcast'].includes(data.meetingRoomParams.type)) {
+      updateAutoWave(false);
+      updateMeetingDisplayType('all');
+      updateForceFullDisplay(true);
+      updateChatSetting('allow');
+      updateItemPageLimit(2);
+
+      if (['broadcast'].includes(data.meetingRoomParams.type)) {
+        updateRecordingVideoOptions('mainScreen');
+        updateRecordingAudioOptions('host');
+        updateItemPageLimit(1);
+      }
+    }
+
+    updateAudioSetting(data.meetingRoomParams.audioSetting);
+    updateVideoSetting(data.meetingRoomParams.videoSetting);
+    updateScreenshareSetting(data.meetingRoomParams.screenshareSetting);
+    updateChatSetting(data.meetingRoomParams.chatSetting);
+
+    updateAudioOnlyRoom(data.meetingRoomParams.mediaType != 'video');
+
+    if (data.meetingRoomParams.type == 'conference' && (shared || shareScreenStarted)) {
+      updateMainHeightWidth(100);
+    } else {
+      updateMainHeightWidth(0);
+    }
+
+    updateScreenPageLimit(Math.min(data.meetingRoomParams.itemPageLimit, screenPageLimit));
+
+    const targetOrientation = islevel == '2'
+      ? data.meetingRoomParams.targetOrientationHost
+      : data.meetingRoomParams.targetOrientation;
+    const targetResolution = islevel == '2'
+      ? data.meetingRoomParams.targetResolutionHost
+      : data.meetingRoomParams.targetResolution;
+
+    let vidCons: VidCons;
+    if (targetOrientation == 'landscape') {
+      vidCons = targetResolution == 'hd'
+        ? hdCons
+        : targetResolution == 'fhd'
+          ? fhdCons
+          : targetResolution == 'qhd'
+            ? qhdCons
+            : targetResolution == 'sd'
+              ? sdCons
+              : QnHDCons;
+    } else if (targetOrientation == 'neutral') {
+      vidCons = targetResolution == 'hd'
+        ? hdConsNeu
+        : targetResolution == 'fhd'
+          ? fhdConsNeu
+          : targetResolution == 'qhd'
+            ? qhdConsNeu
+            : targetResolution == 'sd'
+              ? sdConsNeu
+              : QnHDConsNeu;
+    } else {
+      vidCons = targetResolution == 'hd'
+        ? hdConsPort
+        : targetResolution == 'fhd'
+          ? fhdConsPort
+          : targetResolution == 'qhd'
+            ? qhdConsPort
+            : targetResolution == 'sd'
+              ? sdConsPort
+              : QnHDConsPort;
+    }
+
+    let frameRateValue = frameRate || 10;
+    let vParamsValue = { ...vParams };
+    let hParamsValue = { ...hParams };
+
+    if (Object.keys(vParamsValue).length == 0) {
+      vParamsValue = { ...video_Params };
+    }
+
+    if (Object.keys(hParamsValue).length == 0) {
+      hParamsValue = { ...host_Params };
+    }
+
+    if (targetResolution == 'hd') {
+      frameRateValue = hdFrameRate;
+      vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 4);
+        }
+      });
+
+      hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 4);
+        }
+      });
+    } else if (targetResolution == 'QnHD') {
+      frameRateValue = QnHDFrameRate;
+      vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 0.25);
+        }
+      });
+
+      hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 0.25);
+        }
+      });
+
+      if (hParamsValue.codecOptions && hParamsValue.codecOptions.videoGoogleStartBitrate) {
+        hParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(hParamsValue.codecOptions.videoGoogleStartBitrate * 0.25);
+      }
+      if (vParamsValue.codecOptions && vParamsValue.codecOptions.videoGoogleStartBitrate) {
+        vParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(vParamsValue.codecOptions.videoGoogleStartBitrate * 0.25);
+      }
+    } else if (targetResolution == 'fhd') {
+      frameRateValue = fhdFrameRate;
+      vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 8);
+        }
+      });
+
+      hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 8);
+        }
+      });
+    } else if (targetResolution == 'qhd') {
+      frameRateValue = qhdFrameRate;
+      vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 16);
+        }
+      });
+
+      hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 16);
+        }
+      });
+    }
+
+    if (data.recordingParams.recordingVideoSupport) {
+      vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 1.2);
+        }
+      });
+
+      hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 1.2);
+        }
+      });
+
+      if (hParamsValue.codecOptions && hParamsValue.codecOptions.videoGoogleStartBitrate) {
+        hParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(hParamsValue.codecOptions.videoGoogleStartBitrate * 1.2);
+      }
+      if (vParamsValue.codecOptions && vParamsValue.codecOptions.videoGoogleStartBitrate) {
+        vParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(vParamsValue.codecOptions.videoGoogleStartBitrate * 1.2);
+      }
+    }
+
+    updateVidCons(vidCons);
+    updateFrameRate(frameRateValue);
+    updateHParams(hParamsValue);
+    updateVParams(vParamsValue);
+    updateScreenParams(screen_Params);
+    updateAParams(audio_Params);
+    updateTargetResolution(data.meetingRoomParams.targetResolution);
+    updateTargetResolutionHost(data.meetingRoomParams.targetResolutionHost);
+  } catch (error) {
+    console.log('updateRoomParametersClient error', error);
+    parameters.showAlert?.({
+      message: (error as Error).message,
+      type: 'danger',
+      duration: 3000,
+    });
+  }
+};

package/src/consumers/addVideosGrid.ts

@@ -1,6 +1,8 @@
 // Stub export for addVideosGrid
 // This is a React component in the original and not needed for the shared package
 
+import { createFrameworkConsumerContractError } from './frameworkConsumerContract';
+
 export interface AddVideosGridParameters {
   [key: string]: any;
 }
@@ -13,6 +15,5 @@ export interface AddVideosGridOptions {
 export type AddVideosGridType = (options: AddVideosGridOptions) => Promise<void>;
 
 export const addVideosGrid: AddVideosGridType = async () => {
-  // Stub implementation - actual logic handled in framework-specific packages
-  console.warn('addVideosGrid called on shared package - should be implemented in framework package');
+  throw createFrameworkConsumerContractError('addVideosGrid');
 };