mediasfu-shared 1.0.0

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "mediasfu-shared",
+  "version": "1.0.0",
+  "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"
+  }
+}

package/src/ProducerClient/producerClientEmits/createDeviceClient.ts

@@ -0,0 +1,68 @@
+import * as mediasoupClient from "mediasoup-client";
+import type { RtpCapabilities, Device } from 'mediasoup-client/lib/types';
+
+export interface CreateDeviceClientOptions {
+  rtpCapabilities: RtpCapabilities | null;
+}
+
+
+// Export the type definition for the function
+export type CreateDeviceClientType = (options: CreateDeviceClientOptions) => Promise<Device | null>;
+
+
+/**
+ * Creates a mediasoup client device with the provided RTP capabilities.
+ *
+ * @param {CreateDeviceClientOptions} options - The options for creating the device client.
+ * @param {RTPCapabilities} options.rtpCapabilities - The RTP capabilities required for the device.
+ * @returns {Promise<Device | null>} A promise that resolves to the created Device or null if creation fails.
+ * @throws {Error} Throws an error if the required parameters are not provided or if device creation is not supported.
+ *
+ * @example
+ * const device = await createDeviceClient({ rtpCapabilities });
+ * if (device) {
+ *   console.log("Device created successfully");
+ * } else {
+ *   console.log("Failed to create device");
+ * }
+ */
+
+export const createDeviceClient = async ({
+  rtpCapabilities
+}: CreateDeviceClientOptions): Promise<Device | null> => {
+  try {
+    // Validate input parameters
+    if (!rtpCapabilities) {
+      throw new Error(
+        "Both rtpCapabilities and mediasoupClient must be provided."
+      );
+    }
+
+    // Create a mediasoup client device
+    const device: (Device | null) = new mediasoupClient.Device();
+
+    // Remove orientation capabilities
+    rtpCapabilities.headerExtensions = rtpCapabilities!.headerExtensions!.filter(
+      (ext) => ext.uri !== "urn:3gpp:video-orientation"
+    );
+
+    // Load the provided RTP capabilities into the device
+    await device!.load({
+      routerRtpCapabilities: rtpCapabilities,
+    });
+
+    return device;
+  } catch ( error ) {
+    // Handle specific errors, e.g., UnsupportedError
+    if ( error as Error && (error as Error).name === "UnsupportedError" ) {
+      // Handle unsupported device creation
+      console.error("Device creation is not supported by this browser.");
+    }
+
+    throw error; // Propagate other errors
+  }
+
+};
+
+
+

package/src/consumers/addVideosGrid.ts

@@ -0,0 +1,18 @@
+// Stub export for addVideosGrid
+// This is a React component in the original and not needed for the shared package
+
+export interface AddVideosGridParameters {
+  [key: string]: any;
+}
+
+export interface AddVideosGridOptions {
+  parameters: AddVideosGridParameters;
+  [key: string]: any; // Accept any additional properties
+}
+
+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');
+};

package/src/consumers/autoAdjust.ts

@@ -0,0 +1,100 @@
+import { EventType } from '../types/types';
+
+export interface AutoAdjustOptions {
+  n: number;
+  eventType: EventType;
+  shareScreenStarted: boolean;
+  shared: boolean;  
+}
+
+export type AutoAdjustType = (options: AutoAdjustOptions) => Promise<number[]>;
+
+
+/**
+ * Adjusts values based on the provided options and the number of participants.
+ *
+ * @function
+ * @async
+ * @param {AutoAdjustOptions} options - The options for auto adjustment.
+ * @param {number} options.n - The number of participants.
+ * @param {string} options.eventType - The type of event (e.g., 'broadcast', 'chat', 'conference').
+ * @param {boolean} options.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} options.shared - Indicates if something is shared.
+ * 
+ * @returns {Promise<number[]>} A promise that resolves to an array containing the adjusted values.
+ * 
+ * @example
+ * import { autoAdjust } from 'mediasfu-reactjs';
+ *
+ * const options = {
+ *   n: 10,
+ *   eventType: 'conference',
+ *   shareScreenStarted: false,
+ *   shared: false,
+ * };
+ * 
+ * autoAdjust(options)
+ *   .then(values => {
+ *     console.log('Adjusted values:', values);
+ *   })
+ *   .catch(error => {
+ *     console.error('Error adjusting values:', error);
+ *   });
+ */
+
+export async function autoAdjust({
+  n,
+  eventType, shareScreenStarted, shared
+}: AutoAdjustOptions): Promise<number[]> {
+
+  // Default values
+  let val1 = 6;
+  let val2 = 12 - val1;
+
+  // Adjust values based on eventType and other conditions
+  if (eventType === 'broadcast') {
+    val1 = 0;
+    val2 = 12 - val1;
+  } else if (
+    eventType === 'chat' ||
+    (eventType === 'conference' && !(shareScreenStarted || shared))
+  ) {
+    val1 = 12;
+    val2 = 12 - val1;
+  } else {
+    if (shareScreenStarted || shared) {
+      val2 = 10;
+      val1 = 12 - val2;
+    } else {
+      // Adjust values based on the number of participants (n)
+      if (n === 0) {
+        val1 = 1;
+        val2 = 12 - val1;
+      } else if (n >= 1 && n < 4) {
+        val1 = 4;
+        val2 = 12 - val1;
+      } else if (n >= 4 && n < 6) {
+        val1 = 6;
+        val2 = 12 - val1;
+      } else if (n >= 6 && n < 9) {
+        val1 = 6;
+        val2 = 12 - val1;
+      } else if (n >= 9 && n < 12) {
+        val1 = 6;
+        val2 = 12 - val1;
+      } else if (n >= 12 && n < 20) {
+        val1 = 8;
+        val2 = 12 - val1;
+      } else if (n >= 20 && n < 50) {
+        val1 = 8;
+        val2 = 12 - val1;
+      } else {
+        val1 = 10;
+        val2 = 12 - val1;
+      }
+    }
+  }
+
+  // Return an array with adjusted values
+  return [val1, val2];
+}

package/src/consumers/calculateRowsAndColumns.ts

@@ -0,0 +1,51 @@
+export interface CalculateRowsAndColumnsOptions {
+  n: number;
+}
+
+// Export the type definition for the function
+export type CalculateRowsAndColumnsType = (options: CalculateRowsAndColumnsOptions) => [number, number];
+
+/**
+ * Calculates the number of rows and columns needed to display a given number of items in a grid.
+ *
+ * @function
+ * @param {CalculateRowsAndColumnsOptions} options - The options for calculating rows and columns.
+ * @param {number} options.n - The number of items to display.
+ * @returns {[number, number]} A tuple containing the number of rows and columns.
+ * 
+ * @example
+ * import { calculateRowsAndColumns } from 'mediasfu-reactjs';
+ *
+ * const options = {
+ *   n: 10,
+ * };
+ * 
+ * const [rows, cols] = calculateRowsAndColumns(options);
+ * console.log(`Rows: ${rows}, Columns: ${cols}`); // Outputs: Rows: 4, Columns: 3
+ */
+export function calculateRowsAndColumns({ n }: CalculateRowsAndColumnsOptions): [number, number] {
+  // Calculate the square root of n
+  const sqrt = Math.sqrt(n);
+
+  // Initialize columns based on the floor of the square root
+  let cols = Math.floor(sqrt);
+
+  // Calculate the number of rows needed to display n videos
+  let rows = Math.ceil(n / cols);
+
+  // Calculate the product of rows and columns
+  let prod = rows * cols;
+
+  // Adjust rows and columns until the product is greater than or equal to n
+  while (prod < n) {
+    if (cols < rows) {
+      cols++;
+    } else {
+      rows++;
+    }
+    prod = rows * cols;
+  }
+
+  // Return an array with the calculated number of rows and columns
+  return [rows, cols];
+}