mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/utils/meetingTimer/startMeetingProgressTimer.ts

@@ -0,0 +1,72 @@
+export interface StartMeetingProgressTimerParameters {
+  updateMeetingProgressTime: (formattedTime: string) => void;
+  validated: boolean;
+  roomName: string;
+  getUpdatedAllParams: () => StartMeetingProgressTimerParameters;
+  [key: string]: any;
+}
+
+export interface StartMeetingProgressTimerOptions {
+  startTime: number;
+  parameters: StartMeetingProgressTimerParameters;
+}
+
+export type StartMeetingProgressTimerType = (options: StartMeetingProgressTimerOptions) => void;
+
+/**
+ * Starts a one-second meeting progress timer and updates a formatted elapsed-time string.
+ *
+ * The timer automatically stops when the current runtime parameters indicate the
+ * meeting is no longer validated or no room is active.
+ *
+ * @param options Timer start options.
+ *
+ * @example
+ * ```typescript
+ * startMeetingProgressTimer({
+ *   startTime: Math.floor(Date.now() / 1000),
+ *   parameters: {
+ *     validated: true,
+ *     roomName: 'room123',
+ *     updateMeetingProgressTime: setMeetingTime,
+ *     getUpdatedAllParams: () => currentParams,
+ *   },
+ * });
+ * ```
+ */
+export function startMeetingProgressTimer({
+  startTime,
+  parameters,
+}: StartMeetingProgressTimerOptions): void {
+  let { updateMeetingProgressTime, getUpdatedAllParams } = parameters;
+
+  function calculateElapsedTime(currentStartTime: number): number {
+    const currentTime = Math.floor(new Date().getTime() / 1000);
+    return currentTime - currentStartTime;
+  }
+
+  function padNumber(value: number): string {
+    return value.toString().padStart(2, '0');
+  }
+
+  function formatTime(time: number): string {
+    const hours = Math.floor(time / 3600);
+    const minutes = Math.floor((time % 3600) / 60);
+    const seconds = Math.floor(time % 60);
+    return `${padNumber(hours)}:${padNumber(minutes)}:${padNumber(seconds)}`;
+  }
+
+  let elapsedTime = calculateElapsedTime(startTime);
+
+  let timeProgress: ReturnType<typeof setInterval> | null = setInterval(() => {
+    elapsedTime++;
+    updateMeetingProgressTime(formatTime(elapsedTime));
+
+    parameters = getUpdatedAllParams();
+
+    if (!parameters.validated || !parameters.roomName) {
+      clearInterval(timeProgress!);
+      timeProgress = null;
+    }
+  }, 1000);
+}

package/src/methods/utils/producer/aParams.ts

@@ -0,0 +1,10 @@
+import type { AParamsType } from '../../../types/types';
+
+export const aParams: AParamsType = {
+  encodings: [
+    {
+      rid: 'r0',
+      maxBitrate: 64000,
+    },
+  ],
+};

package/src/methods/utils/producer/hParams.ts

@@ -0,0 +1,26 @@
+import type { HParamsType } from '../../../types/types';
+
+export const hParams: HParamsType = {
+  encodings: [
+    {
+      rid: 'r8',
+      maxBitrate: 240000,
+      scalabilityMode: 'L1T3',
+      scaleResolutionDownBy: 4.0,
+    },
+    {
+      rid: 'r9',
+      maxBitrate: 480000,
+      scalabilityMode: 'L1T3',
+      scaleResolutionDownBy: 2.0,
+    },
+    {
+      rid: 'r10',
+      maxBitrate: 960000,
+      scalabilityMode: 'L1T3',
+    },
+  ],
+  codecOptions: {
+    videoGoogleStartBitrate: 384,
+  },
+};

package/src/methods/utils/producer/screenParams.ts

@@ -0,0 +1,13 @@
+import type { ScreenParamsType } from '../../../types/types';
+
+export const screenParams: ScreenParamsType = {
+  encodings: [
+    {
+      rid: 'r7',
+      maxBitrate: 3000000,
+    },
+  ],
+  codecOptions: {
+    videoGoogleStartBitrate: 1000,
+  },
+};

package/src/methods/utils/producer/vParams.ts

@@ -0,0 +1,26 @@
+import type { VParamsType } from '../../../types/types';
+
+export const vParams: VParamsType = {
+  encodings: [
+    {
+      rid: 'r3',
+      maxBitrate: 200000,
+      scalabilityMode: 'L1T3',
+      scaleResolutionDownBy: 4.0,
+    },
+    {
+      rid: 'r4',
+      maxBitrate: 400000,
+      scalabilityMode: 'L1T3',
+      scaleResolutionDownBy: 2.0,
+    },
+    {
+      rid: 'r5',
+      maxBitrate: 800000,
+      scalabilityMode: 'L1T3',
+    },
+  ],
+  codecOptions: {
+    videoGoogleStartBitrate: 320,
+  },
+};

package/src/methods/utils/producer/videoCaptureConstraints.ts

@@ -0,0 +1,65 @@
+const QnHDCons = { width: { ideal: 320 }, height: { ideal: 180 } };
+const sdCons = { width: { ideal: 640 }, height: { ideal: 360 } };
+const hdCons = { width: { ideal: 1280 }, height: { ideal: 720 } };
+const fhdCons = { width: { ideal: 1920 }, height: { ideal: 1080 } };
+const qhdCons = { width: { ideal: 2560 }, height: { ideal: 1440 } };
+
+const QnHDConsPort = { width: { ideal: 180 }, height: { ideal: 320 } };
+const sdConsPort = { width: { ideal: 360 }, height: { ideal: 640 } };
+const hdConsPort = { width: { ideal: 720 }, height: { ideal: 1280 } };
+const fhdConsPort = { width: { ideal: 1080 }, height: { ideal: 1920 } };
+const qhdConsPort = { width: { ideal: 1440 }, height: { ideal: 2560 } };
+
+const QnHDConsNeu = { width: { ideal: 240 }, height: { ideal: 240 } };
+const sdConsNeu = { width: { ideal: 480 }, height: { ideal: 480 } };
+const hdConsNeu = { width: { ideal: 960 }, height: { ideal: 960 } };
+const fhdConsNeu = { width: { ideal: 1440 }, height: { ideal: 1440 } };
+const qhdConsNeu = { width: { ideal: 1920 }, height: { ideal: 1920 } };
+
+const QnHDFrameRate = 5;
+const sdFrameRate = 10;
+const hdFrameRate = 15;
+const fhdFrameRate = 20;
+const qhdFrameRate = 30;
+const screenFrameRate = 30;
+
+/**
+ * Preset video capture constraints and frame-rate defaults used by MediaSFU.
+ *
+ * These exports provide standard landscape, portrait, and neutral constraint
+ * presets along with recommended frame-rate values for each quality tier.
+ *
+ * @example
+ * ```typescript
+ * const constraints = {
+ *   video: {
+ *     ...hdCons,
+ *     frameRate: { ideal: hdFrameRate },
+ *   },
+ *   audio: false,
+ * };
+ * ```
+ */
+export {
+  QnHDCons,
+  sdCons,
+  hdCons,
+  fhdCons,
+  qhdCons,
+  QnHDConsPort,
+  sdConsPort,
+  hdConsPort,
+  fhdConsPort,
+  qhdConsPort,
+  QnHDConsNeu,
+  sdConsNeu,
+  hdConsNeu,
+  fhdConsNeu,
+  qhdConsNeu,
+  QnHDFrameRate,
+  sdFrameRate,
+  hdFrameRate,
+  fhdFrameRate,
+  qhdFrameRate,
+  screenFrameRate,
+};

package/src/methods/utils/resolveMediaSFURoomApi.ts

@@ -0,0 +1,16 @@
+const DEFAULT_MEDIA_SFU_ROOM_API_URL = 'https://mediasfu.com/v1/rooms/';
+
+type MediaSFURoomApiAction = 'createRoom' | 'joinRoom';
+
+export const resolveMediaSFURoomApi = (
+  localLink: string | undefined,
+  action: MediaSFURoomApiAction,
+): string => {
+  const normalizedLink = localLink?.trim();
+
+  if (!normalizedLink || normalizedLink.includes('mediasfu.com')) {
+    return DEFAULT_MEDIA_SFU_ROOM_API_URL;
+  }
+
+  return `${normalizedLink.replace(/\/$/, '')}/${action}`;
+};

package/src/methods/utils/sleep.ts

@@ -0,0 +1,24 @@
+export interface SleepOptions {
+  ms: number;
+}
+
+export type SleepType = (options: SleepOptions) => Promise<void>;
+
+/**
+ * Delays execution for a specified number of milliseconds.
+ *
+ * This helper is used throughout MediaSFU to wait for short transport or media
+ * lifecycle transitions before continuing work.
+ *
+ * @param options Delay configuration.
+ * @returns A promise that resolves after the requested delay.
+ *
+ * @example
+ * ```typescript
+ * await sleep({ ms: 500 });
+ * // Continue after a half-second pause.
+ * ```
+ */
+export function sleep({ ms }: SleepOptions): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/methods/utils/translationLanguages.ts

@@ -0,0 +1,308 @@
+export type VoiceGender = 'male' | 'female' | 'neutral';
+
+export type TTSSupport = 'excellent' | 'good' | 'moderate' | 'limited' | 'unknown' | 'n/a';
+
+export type LanguageRegion =
+  | 'global'
+  | 'europe'
+  | 'asia'
+  | 'south-asia'
+  | 'mena'
+  | 'africa'
+  | 'caucasus'
+  | 'central-asia'
+  | 'constructed'
+  | 'special'
+  | 'other';
+
+export interface LanguageMetadata {
+  name: string;
+  nativeName: string;
+  region: LanguageRegion;
+  ttsSupport: TTSSupport;
+}
+
+export interface LanguageOption {
+  code: string;
+  name: string;
+  nativeName: string;
+  region: LanguageRegion;
+  ttsSupport: TTSSupport;
+}
+
+export interface VoiceOption {
+  id: string;
+  name: string;
+  gender: VoiceGender;
+  provider: string;
+  language: string;
+  style?: string;
+}
+
+export interface VoiceSelectionPreference {
+  gender: VoiceGender;
+  voiceId?: string;
+  style?: string;
+}
+
+export interface TranslationVoiceConfig {
+  voiceGender?: VoiceGender;
+  voiceId?: string;
+  voiceClone?: {
+    provider: 'elevenlabs' | 'playht' | 'coqui' | 'cartesia';
+    voiceId: string;
+    stability?: number;
+    similarity?: number;
+  };
+  sttNickName?: string;
+  llmNickName?: string;
+  ttsNickName?: string;
+  ttsProvider?: string;
+  sttParams?: Record<string, string | number | boolean>;
+  llmParams?: Record<string, string | number | boolean>;
+  ttsParams?: Record<string, string | number | boolean>;
+}
+
+export interface TranslationLanguageEntry {
+  code: string;
+  nickname?: string;
+  voiceConfig?: TranslationVoiceConfig;
+}
+
+export const SUPPORTED_LANGUAGE_CODES: string[] = [
+  'en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'zh', 'ja', 'ko', 'ar',
+  'hi', 'bn', 'pa', 'te', 'mr', 'ta', 'ur', 'gu', 'kn', 'ml', 'ne', 'si',
+  'nl', 'pl', 'tr', 'cs', 'el', 'hu', 'ro', 'sv', 'da', 'fi', 'no', 'sk',
+  'uk', 'bg', 'hr', 'et', 'lt', 'lv', 'sl', 'sr', 'bs', 'mk', 'is',
+  'ga', 'cy', 'mt', 'lb', 'sq', 'be',
+  'he', 'fa', 'ps', 'ku',
+  'vi', 'th', 'id', 'ms', 'tl', 'km', 'lo', 'my',
+  'sw', 'yo', 'ig', 'ha', 'zu', 'xh', 'af', 'st', 'tn', 'sn', 'am', 'so', 'rw', 'mg', 'ny',
+  'ee', 'tw', 'gaa',
+  'ka', 'hy', 'az',
+  'eu', 'gl', 'ca', 'la', 'eo',
+  'kk', 'uz', 'tg', 'ky', 'tk', 'mn',
+  'auto',
+];
+
+const REGION_BY_LANGUAGE: Record<string, LanguageRegion> = {
+  en: 'global', es: 'global', fr: 'europe', de: 'europe', it: 'europe', pt: 'global', ru: 'europe', zh: 'asia', ja: 'asia', ko: 'asia', ar: 'mena',
+  hi: 'south-asia', bn: 'south-asia', pa: 'south-asia', te: 'south-asia', mr: 'south-asia', ta: 'south-asia', ur: 'south-asia', gu: 'south-asia', kn: 'south-asia', ml: 'south-asia', ne: 'south-asia', si: 'south-asia',
+  nl: 'europe', pl: 'europe', tr: 'europe', cs: 'europe', el: 'europe', hu: 'europe', ro: 'europe', sv: 'europe', da: 'europe', fi: 'europe', no: 'europe', sk: 'europe', uk: 'europe', bg: 'europe', hr: 'europe', et: 'europe', lt: 'europe', lv: 'europe', sl: 'europe', sr: 'europe', bs: 'europe', mk: 'europe', is: 'europe', ga: 'europe', cy: 'europe', mt: 'europe', lb: 'europe', sq: 'europe', be: 'europe',
+  he: 'mena', fa: 'mena', ps: 'mena', ku: 'mena',
+  vi: 'asia', th: 'asia', id: 'asia', ms: 'asia', tl: 'asia', km: 'asia', lo: 'asia', my: 'asia',
+  sw: 'africa', yo: 'africa', ig: 'africa', ha: 'africa', zu: 'africa', xh: 'africa', af: 'africa', st: 'africa', tn: 'africa', sn: 'africa', am: 'africa', so: 'africa', rw: 'africa', mg: 'africa', ny: 'africa', ee: 'africa', tw: 'africa', gaa: 'africa',
+  ka: 'caucasus', hy: 'caucasus', az: 'caucasus',
+  eu: 'europe', gl: 'europe', ca: 'europe', la: 'europe', eo: 'constructed',
+  kk: 'central-asia', uz: 'central-asia', tg: 'central-asia', ky: 'central-asia', tk: 'central-asia', mn: 'central-asia',
+  auto: 'special',
+};
+
+const TTS_SUPPORT_BY_LANGUAGE: Record<string, TTSSupport> = {
+  en: 'excellent', es: 'excellent', fr: 'excellent', de: 'excellent', it: 'excellent', pt: 'excellent', ru: 'excellent', zh: 'excellent', ja: 'excellent', ko: 'excellent', ar: 'excellent',
+  hi: 'good', bn: 'good', te: 'good', mr: 'good', ta: 'good', ur: 'good', nl: 'excellent', pl: 'excellent', tr: 'excellent', cs: 'good', el: 'good', hu: 'good', ro: 'good', sv: 'excellent',
+  da: 'good', fi: 'good', no: 'good', uk: 'good', he: 'good', vi: 'good', th: 'good', id: 'good', ms: 'good', af: 'good', ca: 'good',
+  auto: 'n/a',
+};
+
+const getDisplayName = (code: string, locale: string, fallback: string) => {
+  try {
+    const displayNames = new Intl.DisplayNames([locale], { type: 'language' });
+    return displayNames.of(code) || fallback;
+  } catch {
+    return fallback;
+  }
+};
+
+export const normalizeLanguageCode = (code: string): string => {
+  if (!code || typeof code !== 'string') {
+    return 'en';
+  }
+
+  return code.trim().toLowerCase().split('-')[0];
+};
+
+export const isLanguageSupported = (code: string): boolean => {
+  const normalized = normalizeLanguageCode(code);
+  return SUPPORTED_LANGUAGE_CODES.includes(normalized);
+};
+
+export const getLanguageName = (code: string, displayLocale = 'en'): string => {
+  const normalized = normalizeLanguageCode(code);
+  if (normalized === 'auto') {
+    return 'Auto-detect';
+  }
+
+  return getDisplayName(normalized, displayLocale, normalized.toUpperCase());
+};
+
+export const getLanguageNativeName = (code: string): string => {
+  const normalized = normalizeLanguageCode(code);
+  if (normalized === 'auto') {
+    return 'Auto';
+  }
+
+  return getDisplayName(normalized, normalized, getLanguageName(normalized));
+};
+
+export const getLanguageMetadata = (code: string): LanguageMetadata => {
+  const normalized = normalizeLanguageCode(code);
+
+  return {
+    name: getLanguageName(normalized),
+    nativeName: getLanguageNativeName(normalized),
+    region: REGION_BY_LANGUAGE[normalized] || 'other',
+    ttsSupport: TTS_SUPPORT_BY_LANGUAGE[normalized] || 'unknown',
+  };
+};
+
+export const getSupportedLanguages = (displayLocale = 'en'): LanguageOption[] => {
+  return SUPPORTED_LANGUAGE_CODES.map((code) => {
+    const metadata = getLanguageMetadata(code);
+    return {
+      code,
+      name: getLanguageName(code, displayLocale),
+      nativeName: metadata.nativeName,
+      region: metadata.region,
+      ttsSupport: metadata.ttsSupport,
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+};
+
+export type TTSProvider =
+  | 'deepgram'
+  | 'openai'
+  | 'azure'
+  | 'google'
+  | 'aws'
+  | 'elevenlabs'
+  | 'playht'
+  | 'cartesia'
+  | 'rime'
+  | 'kokoro'
+  | 'gemini'
+  | 'assemblyai';
+
+export const TTS_PROVIDERS: Record<TTSProvider, { name: string; supportsSSML: boolean; multilingual?: boolean; isDefault?: boolean }> = {
+  deepgram: { name: 'Deepgram Aura', supportsSSML: false, isDefault: true },
+  openai: { name: 'OpenAI TTS', supportsSSML: false, multilingual: true },
+  azure: { name: 'Azure Neural TTS', supportsSSML: true },
+  google: { name: 'Google Cloud TTS', supportsSSML: true },
+  aws: { name: 'AWS Polly', supportsSSML: true },
+  elevenlabs: { name: 'ElevenLabs', supportsSSML: false, multilingual: true },
+  playht: { name: 'PlayHT', supportsSSML: false, multilingual: true },
+  cartesia: { name: 'Cartesia Sonic', supportsSSML: false, multilingual: true },
+  rime: { name: 'Rime AI', supportsSSML: false, multilingual: true },
+  kokoro: { name: 'Kokoro', supportsSSML: false, multilingual: true },
+  gemini: { name: 'Google Gemini TTS', supportsSSML: false, multilingual: true },
+  assemblyai: { name: 'AssemblyAI', supportsSSML: false },
+};
+
+export interface SocketVoiceResponse {
+  provider: string;
+  language: string;
+  voices: { male: VoiceOption[]; female: VoiceOption[] };
+  providers?: Record<string, unknown>;
+  error?: string;
+}
+
+const buildFallbackVoices = (langCode: string, provider: string): { male: VoiceOption[]; female: VoiceOption[] } => {
+  const normalizedLanguage = normalizeLanguageCode(langCode === 'auto' ? 'en' : langCode);
+  const providerKey = provider.toLowerCase();
+  const providerName = TTS_PROVIDERS[providerKey as TTSProvider]?.name || provider;
+  const languageName = getLanguageName(normalizedLanguage);
+
+  return {
+    female: [
+      {
+        id: `${providerKey}-${normalizedLanguage}-female-1`,
+        name: `${providerName} ${languageName} Female`,
+        gender: 'female',
+        provider: providerKey,
+        language: normalizedLanguage,
+      },
+      {
+        id: `${providerKey}-${normalizedLanguage}-female-2`,
+        name: `${providerName} ${languageName} Female 2`,
+        gender: 'female',
+        provider: providerKey,
+        language: normalizedLanguage,
+      },
+    ],
+    male: [
+      {
+        id: `${providerKey}-${normalizedLanguage}-male-1`,
+        name: `${providerName} ${languageName} Male`,
+        gender: 'male',
+        provider: providerKey,
+        language: normalizedLanguage,
+      },
+      {
+        id: `${providerKey}-${normalizedLanguage}-male-2`,
+        name: `${providerName} ${languageName} Male 2`,
+        gender: 'male',
+        provider: providerKey,
+        language: normalizedLanguage,
+      },
+    ],
+  };
+};
+
+export const getAvailableVoices = (
+  langCode: string,
+  provider: TTSProvider | string = 'deepgram'
+): { male: VoiceOption[]; female: VoiceOption[] } => {
+  return buildFallbackVoices(langCode, provider.toString());
+};
+
+export const fetchVoicesViaSocket = (
+  socket: { emit: (event: string, data: unknown, callback?: (response: SocketVoiceResponse) => void) => void },
+  provider: TTSProvider | string = 'deepgram',
+  language: string = 'en'
+): Promise<SocketVoiceResponse> => {
+  return new Promise((resolve) => {
+    const providerName = provider.toString();
+    const fallbackVoices = getAvailableVoices(language, providerName);
+
+    const timeout = setTimeout(() => {
+      resolve({
+        provider: providerName,
+        language,
+        voices: fallbackVoices,
+        error: 'Request timed out, using shared fallback voices',
+      });
+    }, 5000);
+
+    socket.emit('translation:getVoices', { provider, language }, (response: SocketVoiceResponse) => {
+      clearTimeout(timeout);
+
+      if (response?.voices) {
+        resolve(response);
+        return;
+      }
+
+      resolve({
+        provider: response?.provider || providerName,
+        language: response?.language || language,
+        voices: fallbackVoices,
+        error: response?.error || 'No voices returned, using shared fallback voices',
+      });
+    });
+  });
+};
+
+export const fetchLanguagesViaSocket = (
+  socket: { emit: (event: string, data: unknown, callback?: (response: { languages?: LanguageOption[] }) => void) => void },
+  displayLocale: string = 'en'
+): Promise<LanguageOption[]> => {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve(getSupportedLanguages(displayLocale));
+    }, 5000);
+
+    socket.emit('translation:getLanguages', { displayLocale }, (response: { languages?: LanguageOption[] }) => {
+      clearTimeout(timeout);
+      resolve(response?.languages?.length ? response.languages : getSupportedLanguages(displayLocale));
+    });
+  });
+};

package/src/methods/utils/webrtc.ts

@@ -0,0 +1,44 @@
+// Default fallback
+// Fallback for mediaDevices with support for getUserMedia
+export const mediaDevices = {
+  getUserMedia: async (_constraints: MediaStreamConstraints): Promise<MediaStream> => {
+    // Fallback logic or mock implementation for getUserMedia
+    console.warn('getUserMedia is not implemented in this environment.');
+    return new MediaStream(); // Return an empty MediaStream as a fallback
+  },
+
+  getDisplayMedia: async (_constraints: MediaStreamConstraints): Promise<MediaStream> => {
+    // Fallback logic or mock implementation for getDisplayMedia
+    console.warn('getDisplayMedia is not implemented in this environment.');
+    return new MediaStream(); // Return an empty MediaStream as a fallback
+  },
+
+  enumerateDevices: async (): Promise<MediaDeviceInfo[]> => {
+    // Fallback logic or mock implementation for enumerateDevices
+    console.warn('enumerateDevices is not implemented in this environment.');
+    return []; // Return an empty array as a fallback
+  },
+};
+
+export function registerGlobals() {}
+
+export class MediaStream {
+  tracks: any[];
+
+  constructor(tracks: any[] = []) {
+    this.tracks = tracks; // Assign tracks to the MediaStream instance
+  }
+
+  // You can add additional methods or properties if needed
+  [key: string]: any;
+}
+
+export class MediaStreamTrack {
+  [key: string]: any;
+}
+
+export class RTCView {
+  render(): null {
+    return null; // Empty RTCView implementation
+  }
+}

package/src/methods/welcome/handleWelcomeRequest.ts

@@ -1,4 +1,4 @@
-import { Socket } from 'socket.io-client';
+import type { Socket } from 'socket.io-client';
 import Cookies from 'universal-cookie';
 import type { PreJoinPageParameters } from '../../types/types';
 
@@ -6,6 +6,15 @@ const cookies = new Cookies();
 const MAX_ATTEMPTS = 10;
 const RATE_LIMIT_DURATION = 3 * 60 * 60 * 1000; // 3 hours
 
+const hasConnectedSocketId = (socket: unknown): socket is Socket & { id: string } => {
+  if (!socket || typeof socket !== 'object') {
+    return false;
+  }
+
+  const candidate = socket as { id?: unknown };
+  return typeof candidate.id === 'string' && candidate.id.length > 0;
+};
+
 /**
  * Options for handleWelcomeRequest function
  */
@@ -143,7 +152,7 @@ export async function handleWelcomeRequest({
 
     const socket = await Promise.race([socketPromise, timeoutPromise]);
 
-    if (socket && socket instanceof Socket && socket.id) {
+    if (hasConnectedSocketId(socket)) {
       unsuccessfulAttempts = 0;
       cookies.set('unsuccessfulAttempts', unsuccessfulAttempts.toString());
       cookies.set('lastRequestTimestamp', Date.now().toString());

package/src/methods/welcome/index.ts

@@ -1,4 +1,8 @@
-export { handleWelcomeRequest, validateAlphanumeric, validateWelcomeInputs } from './handleWelcomeRequest';
+export {
+  handleWelcomeRequest,
+  validateAlphanumeric as validateWelcomeAlphanumeric,
+  validateWelcomeInputs,
+} from './handleWelcomeRequest';
 export type {
   HandleWelcomeRequestOptions,
   ValidateWelcomeInputsOptions,