@unboundcx/video-sdk-client 1.1.0

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@unboundcx/video-sdk-client",
+	"version": "1.1.0",
+	"description": "Framework-agnostic WebRTC video meeting SDK powered by mediasoup",
+	"type": "module",
+	"main": "index.js",
+	"exports": {
+		".": "./index.js",
+		"./client": "./VideoMeetingClient.js",
+		"./managers/*": "./managers/*.js",
+		"./utils/*": "./utils/*.js"
+	},
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"keywords": [
+		"webrtc",
+		"video",
+		"meeting",
+		"mediasoup",
+		"conferencing",
+		"real-time",
+		"streaming",
+		"sfu"
+	],
+	"author": "UnboundCX",
+	"license": "MIT",
+	"peerDependencies": {
+		"mediasoup-client": "^3.x",
+		"socket.io-client": "^4.x"
+	},
+	"dependencies": {
+		"@mediapipe/selfie_segmentation": "^0.1.1675465747"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/unboundcx/video-sdk"
+	},
+	"bugs": {
+		"url": "https://github.com/unboundcx/video-sdk/issues"
+	},
+	"homepage": "https://github.com/unboundcx/video-sdk#readme",
+	"files": [
+		"index.js",
+		"VideoMeetingClient.js",
+		"VideoProcessor.js",
+		"AudioMixer.js",
+		"managers/",
+		"utils/",
+		"README.md",
+		"LICENSE"
+	],
+	"engines": {
+		"node": ">=14.0.0"
+	}
+}

package/utils/EventEmitter.js

@@ -0,0 +1,103 @@
+/**
+ * Simple EventEmitter implementation for the SDK
+ * Allows subscribing to and emitting events
+ */
+export class EventEmitter {
+	constructor() {
+		this._events = new Map();
+	}
+
+	/**
+	 * Subscribe to an event
+	 * @param {string} event - Event name
+	 * @param {Function} handler - Event handler function
+	 * @returns {Function} Unsubscribe function
+	 */
+	on(event, handler) {
+		if (!this._events.has(event)) {
+			this._events.set(event, []);
+		}
+
+		const handlers = this._events.get(event);
+		handlers.push(handler);
+
+		// Return unsubscribe function
+		return () => {
+			const index = handlers.indexOf(handler);
+			if (index > -1) {
+				handlers.splice(index, 1);
+			}
+		};
+	}
+
+	/**
+	 * Subscribe to an event that only fires once
+	 * @param {string} event - Event name
+	 * @param {Function} handler - Event handler function
+	 * @returns {Function} Unsubscribe function
+	 */
+	once(event, handler) {
+		const wrappedHandler = (...args) => {
+			handler(...args);
+			this.off(event, wrappedHandler);
+		};
+
+		return this.on(event, wrappedHandler);
+	}
+
+	/**
+	 * Unsubscribe from an event
+	 * @param {string} event - Event name
+	 * @param {Function} handler - Event handler function to remove
+	 */
+	off(event, handler) {
+		const handlers = this._events.get(event);
+		if (!handlers) return;
+
+		const index = handlers.indexOf(handler);
+		if (index > -1) {
+			handlers.splice(index, 1);
+		}
+	}
+
+	/**
+	 * Emit an event to all subscribers
+	 * @param {string} event - Event name
+	 * @param {*} data - Event data
+	 */
+	emit(event, data) {
+		const handlers = this._events.get(event);
+		if (!handlers || handlers.length === 0) return;
+
+		// Call all handlers with the event data
+		for (const handler of handlers) {
+			try {
+				handler(data);
+			} catch (error) {
+				console.error(`Error in event handler for "${event}":`, error);
+			}
+		}
+	}
+
+	/**
+	 * Remove all event listeners
+	 * @param {string?} event - Optional event name to clear only that event
+	 */
+	removeAllListeners(event = null) {
+		if (event) {
+			this._events.delete(event);
+		} else {
+			this._events.clear();
+		}
+	}
+
+	/**
+	 * Get count of listeners for an event
+	 * @param {string} event - Event name
+	 * @returns {number} Number of listeners
+	 */
+	listenerCount(event) {
+		const handlers = this._events.get(event);
+		return handlers ? handlers.length : 0;
+	}
+}

package/utils/Logger.js

@@ -0,0 +1,114 @@
+/**
+ * Logger utility with namespaced prefixes and debug mode
+ */
+
+// Global filters for verbose logs (stats, keepalive, etc.)
+const globalFilters = {
+	stats: false,
+	keepalive: false,
+	performance: false,
+};
+
+export class Logger {
+	/**
+	 * @param {string} namespace - Logger namespace (e.g., 'SDK:ConnectionManager')
+	 * @param {boolean} debug - Enable debug logging
+	 */
+	constructor(namespace, debug = false) {
+		this.namespace = namespace;
+		this.debug = debug;
+	}
+
+	/**
+	 * Set global filter for verbose log categories
+	 * @param {string} category - Category name (stats, keepalive, performance)
+	 * @param {boolean} enabled - Enable or disable this category
+	 */
+	static setFilter(category, enabled) {
+		if (category in globalFilters) {
+			globalFilters[category] = enabled;
+		}
+	}
+
+	/**
+	 * Enable/disable all verbose logging categories
+	 * @param {boolean} enabled - Enable or disable verbose logs
+	 */
+	static setVerbose(enabled) {
+		Object.keys(globalFilters).forEach(key => {
+			globalFilters[key] = enabled;
+		});
+	}
+
+	/**
+	 * Check if a message should be filtered based on content
+	 * @private
+	 */
+	_shouldFilter(args) {
+		const message = args.join(' ').toLowerCase();
+
+		if (!globalFilters.stats && (message.includes('stats') || message.includes('mos'))) {
+			return true;
+		}
+		if (!globalFilters.keepalive && message.includes('keepalive')) {
+			return true;
+		}
+		if (!globalFilters.performance && message.includes('performance')) {
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Format message with namespace prefix
+	 * @private
+	 */
+	_format(level, ...args) {
+		const prefix = `[${this.namespace}]`;
+		return [prefix, ...args];
+	}
+
+	/**
+	 * Log info message
+	 */
+	info(...args) {
+		if (this.debug && !this._shouldFilter(args)) {
+			console.log(...this._format('INFO', ...args));
+		}
+	}
+
+	/**
+	 * Log warning message
+	 */
+	warn(...args) {
+		if (!this._shouldFilter(args)) {
+			console.warn(...this._format('WARN', ...args));
+		}
+	}
+
+	/**
+	 * Log error message (never filtered)
+	 */
+	error(...args) {
+		console.error(...this._format('ERROR', ...args));
+	}
+
+	/**
+	 * Log debug message (only in debug mode)
+	 */
+	log(...args) {
+		if (this.debug && !this._shouldFilter(args)) {
+			console.log(...this._format('DEBUG', ...args));
+		}
+	}
+
+	/**
+	 * Create a child logger with additional namespace
+	 * @param {string} childNamespace - Additional namespace to append
+	 * @returns {Logger} New logger instance
+	 */
+	child(childNamespace) {
+		return new Logger(`${this.namespace}:${childNamespace}`, this.debug);
+	}
+}

package/utils/errors.js

@@ -0,0 +1,136 @@
+/**
+ * Custom error classes for the SDK
+ * These provide better error handling and debugging
+ */
+
+/**
+ * Base SDK Error class
+ */
+export class SDKError extends Error {
+	constructor(message, code = 'SDK_ERROR') {
+		super(message);
+		this.name = 'SDKError';
+		this.code = code;
+		this.timestamp = new Date().toISOString();
+	}
+}
+
+/**
+ * Connection-related errors
+ */
+export class ConnectionError extends SDKError {
+	constructor(message, details = {}) {
+		super(message, 'CONNECTION_ERROR');
+		this.name = 'ConnectionError';
+		this.details = details;
+	}
+}
+
+/**
+ * Device/media permission errors
+ */
+export class PermissionDeniedError extends SDKError {
+	constructor(deviceType, originalError = null) {
+		super(
+			`Permission denied for ${deviceType}. Please allow access in your browser settings.`,
+			'PERMISSION_DENIED'
+		);
+		this.name = 'PermissionDeniedError';
+		this.deviceType = deviceType;
+		this.originalError = originalError;
+	}
+}
+
+/**
+ * Device not found errors
+ */
+export class DeviceNotFoundError extends SDKError {
+	constructor(deviceType, deviceId = null) {
+		super(
+			`${deviceType} device not found${deviceId ? ` (ID: ${deviceId})` : ''}`,
+			'DEVICE_NOT_FOUND'
+		);
+		this.name = 'DeviceNotFoundError';
+		this.deviceType = deviceType;
+		this.deviceId = deviceId;
+	}
+}
+
+/**
+ * mediasoup-related errors
+ */
+export class MediasoupError extends SDKError {
+	constructor(message, operation = null, originalError = null) {
+		super(message, 'MEDIASOUP_ERROR');
+		this.name = 'MediasoupError';
+		this.operation = operation;
+		this.originalError = originalError;
+	}
+}
+
+/**
+ * State-related errors (invalid state transitions)
+ */
+export class StateError extends SDKError {
+	constructor(message, currentState = null, expectedState = null) {
+		super(message, 'STATE_ERROR');
+		this.name = 'StateError';
+		this.currentState = currentState;
+		this.expectedState = expectedState;
+	}
+}
+
+/**
+ * Room/meeting errors
+ */
+export class RoomError extends SDKError {
+	constructor(message, roomId = null) {
+		super(message, 'ROOM_ERROR');
+		this.name = 'RoomError';
+		this.roomId = roomId;
+	}
+}
+
+/**
+ * Timeout errors
+ */
+export class TimeoutError extends SDKError {
+	constructor(operation, timeoutMs) {
+		super(
+			`Operation "${operation}" timed out after ${timeoutMs}ms`,
+			'TIMEOUT_ERROR'
+		);
+		this.name = 'TimeoutError';
+		this.operation = operation;
+		this.timeoutMs = timeoutMs;
+	}
+}
+
+/**
+ * Helper function to wrap unknown errors
+ * @param {Error} error - Original error
+ * @param {string} context - Context where error occurred
+ * @returns {SDKError} Wrapped error
+ */
+export function wrapError(error, context) {
+	if (error instanceof SDKError) {
+		return error;
+	}
+
+	// Check for common browser errors
+	if (error.name === 'NotAllowedError' || error.name === 'PermissionDeniedError') {
+		return new PermissionDeniedError(context, error);
+	}
+
+	if (error.name === 'NotFoundError' || error.name === 'DevicesNotFoundError') {
+		return new DeviceNotFoundError(context, null);
+	}
+
+	// Wrap as generic SDK error
+	const sdkError = new SDKError(
+		`${context}: ${error.message}`,
+		'UNKNOWN_ERROR'
+	);
+	sdkError.originalError = error;
+	return sdkError;
+}