@memori.ai/memori-react 7.34.2 → 8.0.0-rc.1

package/src/context/visemeContext.tsx

@@ -28,6 +28,13 @@ interface VisemeContextType {
 
 const VisemeContext = createContext<VisemeContextType | undefined>(undefined);
 
+// Add this interface at the top near your other types
+interface SimpleAudioWrapper {
+  currentTime: number;
+  state: string;
+  onstatechange: ((this: AudioContext, ev: Event) => any) | null;
+}
+
 const VISEME_MAP: Readonly<{ [key: number]: string }> = {
   0: 'viseme_sil', // silence
   1: 'viseme_PP', // p, b, m
@@ -142,30 +149,59 @@ export const VisemeProvider: React.FC<{ children: React.ReactNode }> = ({
   const frameCountRef = useRef(0);
   const firstVisemeTimeRef = useRef<number | null>(null);
 
-  const setAudioContext = useCallback((ctx: IAudioContext) => {
-    audioContextRef.current = ctx;
-
-    // Listen to audio context state changes
-    ctx.onstatechange = () => {
-      // logVisemeEvent('Audio Context State Change', {
-      //   state: ctx.state,
-      //   currentTime: ctx.currentTime,
-      // });
+  // Update the setAudioContext function
+  const setAudioContext = useCallback(
+    (ctx: IAudioContext | SimpleAudioWrapper) => {
+      audioContextRef.current = ctx as IAudioContext;
+
+      // Listen to audio context state changes
+      if (ctx.onstatechange !== null) {
+        ctx.onstatechange = () => {
+          switch (ctx.state) {
+            case 'running':
+              setVisemeState('active');
+              break;
+            case 'suspended':
+              setVisemeState('paused');
+              break;
+            case 'closed':
+              setVisemeState('finished');
+              stopProcessing();
+              break;
+          }
+        };
+      }
+    },
+    []
+  );
 
-      switch (ctx.state) {
-        case 'running':
-          setVisemeState('active');
-          break;
-        case 'suspended':
-          setVisemeState('paused');
-          break;
-        case 'closed':
-          setVisemeState('finished');
-          stopProcessing();
-          break;
+  // Update the startProcessing function
+  const startProcessing = useCallback(
+    (audioCtx: IAudioContext | SimpleAudioWrapper) => {
+      if (!audioCtx) {
+        console.error('[VisemeContext] No audio context provided');
+        return;
       }
-    };
-  }, []);
+
+      audioContextRef.current = audioCtx as IAudioContext;
+
+      // Initialize with the current time of the audio context
+      audioStartTimeRef.current = audioCtx.currentTime;
+
+      // Reset frame counter
+      frameCountRef.current = 0;
+
+      // Update state
+      setIsProcessing(true);
+      setVisemeState('active');
+
+      console.log('[VisemeContext] Started processing visemes', {
+        audioTime: audioCtx.currentTime,
+        queueLength: visemeQueueRef.current.length,
+      });
+    },
+    []
+  );
 
   const addViseme = useCallback(
     (visemeId: number, audioOffset: number) => {
@@ -209,37 +245,36 @@ export const VisemeProvider: React.FC<{ children: React.ReactNode }> = ({
     [visemeState]
   );
 
-  const startProcessing = useCallback((audioCtx: IAudioContext) => {
-    if (!audioCtx) {
-      // logVisemeError('No audio context provided', { state: visemeState });
-      return;
-    }
+  // Make resetVisemeQueue more robust
+  const resetVisemeQueue = useCallback(() => {
+    console.log('[VisemeContext] Resetting viseme queue');
+
+    // Clear all queued visemes
+    visemeQueueRef.current = [];
 
-    audioContextRef.current = audioCtx;
-    audioStartTimeRef.current = audioCtx.currentTime;
+    // Reset all other state
+    lastVisemeRef.current = null;
+    audioStartTimeRef.current = null;
+    firstVisemeTimeRef.current = null;
     frameCountRef.current = 0;
-    setIsProcessing(true);
-    setVisemeState('active');
-
-    // logVisemeEvent('Started Processing', {
-    //   audioTime: audioCtx.currentTime,
-    //   queueLength: visemeQueueRef.current.length,
-    //   state: visemeState,
-    // });
+
+    // Set state back to idle
+    setVisemeState('idle');
   }, []);
 
+  // Make stopProcessing more robust
   const stopProcessing = useCallback(() => {
+    console.log('[VisemeContext] Stopping viseme processing');
+
+    // Update processing state first
     setIsProcessing(false);
     setVisemeState('finished');
+
+    // Then reset all refs
     audioStartTimeRef.current = null;
     lastVisemeRef.current = null;
     frameCountRef.current = 0;
     audioContextRef.current = null;
-
-    // logVisemeEvent('Stopped Processing', {
-    //   queueLength: visemeQueueRef.current.length,
-    //   state: visemeState,
-    // });
   }, []);
 
   const updateCurrentViseme = useCallback(
@@ -303,19 +338,6 @@ export const VisemeProvider: React.FC<{ children: React.ReactNode }> = ({
     [isProcessing]
   );
 
-  const resetVisemeQueue = useCallback(() => {
-    visemeQueueRef.current = [];
-    lastVisemeRef.current = null;
-    audioStartTimeRef.current = null;
-    firstVisemeTimeRef.current = null;
-    frameCountRef.current = 0;
-    setVisemeState('idle');
-
-    // logVisemeEvent('Reset Viseme Queue', {
-    //   previousState: visemeState,
-    // });
-  }, [visemeState]);
-
   const resetAndStartProcessing = useCallback(
     (audioCtx: IAudioContext) => {
       // logVisemeEvent('Reset And Start Processing', {

package/src/helpers/sanitizer.ts

@@ -0,0 +1,71 @@
+// tts/TextSanitizer.ts
+
+/**
+ * Rimuove la formattazione Markdown dal testo
+ * @param text Testo da processare
+ */
+export function stripMarkdown(text: string): string {
+    return text
+      .replace(/\*\*(.*?)\*\*/g, '$1') // Bold
+      .replace(/\*(.*?)\*/g, '$1')     // Italic
+      .replace(/__(.*?)__/g, '$1')     // Bold
+      .replace(/_(.*?)_/g, '$1')       // Italic
+      .replace(/~~(.*?)~~/g, '$1')     // Strikethrough
+      .replace(/```(.*?)```/gs, '$1')  // Code blocks
+      .replace(/`(.*?)`/g, '$1')       // Inline code
+      .replace(/\[(.*?)\]\((.*?)\)/g, '$1'); // Links
+  }
+  
+  /**
+   * Rimuove gli emoji dal testo
+   * @param text Testo da processare
+   */
+  export function stripEmojis(text: string): string {
+    return text.replace(/[\u{1F600}-\u{1F64F}|\u{1F300}-\u{1F5FF}|\u{1F680}-\u{1F6FF}|\u{2600}-\u{26FF}|\u{2700}-\u{27BF}]/gu, '');
+  }
+  
+  /**
+   * Rimuove i tag HTML dal testo
+   * @param text Testo da processare
+   */
+  export function stripHTML(text: string): string {
+    return text.replace(/<[^>]*>/g, '');
+  }
+  
+  /**
+   * Rimuove i tag di output specifici dal testo
+   * @param text Testo da processare
+   */
+  export function stripOutputTags(text: string): string {
+    // Implementa se necessario per il tuo caso specifico
+    return text;
+  }
+  
+  /**
+   * Esegue l'escape dei caratteri speciali HTML
+   * @param text Testo da processare
+   */
+  export function escapeHTML(text: string): string {
+    return text
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&apos;');
+  }
+  
+  /**
+   * Sanitizza completamente il testo per la sintesi vocale
+   * @param text Testo da sanitizzare
+   */
+  export function sanitizeText(text: string): string {
+    return escapeHTML(
+      stripMarkdown(
+        stripEmojis(
+          stripHTML(
+            stripOutputTags(text)
+          )
+        )
+      )
+    );
+  }

package/src/helpers/tts/ttsVoiceUtility.ts

@@ -0,0 +1,275 @@
+// tts/voiceUtils.ts
+import { TTSConfig } from './useTTS';
+
+// Azure voices organized by language and gender
+export const AZURE_VOICES = {
+  IT: {
+    MALE: 'it-IT-DiegoNeural',
+    FEMALE: 'it-IT-ElsaNeural'
+  },
+  DE: {
+    MALE: 'de-DE-ConradNeural', 
+    FEMALE: 'de-DE-KatjaNeural'
+  },
+  EN: {
+    MALE: 'en-GB-RyanNeural', 
+    FEMALE: 'en-GB-SoniaNeural'
+  },
+  ES: {
+    MALE: 'es-ES-AlvaroNeural', 
+    FEMALE: 'es-ES-ElviraNeural'
+  },
+  FR: {
+    MALE: 'fr-FR-HenriNeural', 
+    FEMALE: 'fr-FR-DeniseNeural'
+  },
+  PT: {
+    MALE: 'pt-PT-DuarteNeural', 
+    FEMALE: 'pt-PT-RaquelNeural'
+  },
+  UK: {
+    MALE: 'uk-UA-OstapNeural', 
+    FEMALE: 'uk-UA-PolinaNeural'
+  },
+  RU: {
+    MALE: 'ru-RU-DmitryNeural', 
+    FEMALE: 'ru-RU-SvetlanaNeural'
+  },
+  PL: {
+    MALE: 'pl-PL-MarekNeural', 
+    FEMALE: 'pl-PL-AgnieszkaNeural'
+  },
+  FI: {
+    MALE: 'fi-FI-HarriNeural', 
+    FEMALE: 'fi-FI-SelmaNeural'
+  },
+  EL: {
+    MALE: 'el-GR-NestorasNeural', 
+    FEMALE: 'el-GR-AthinaNeural'
+  },
+  AR: {
+    MALE: 'ar-SA-HamedNeural', 
+    FEMALE: 'ar-SA-ZariyahNeural'
+  },
+  ZH: {
+    MALE: 'zh-CN-YunxiNeural', 
+    FEMALE: 'zh-CN-XiaoxiaoNeural'
+  },
+  JA: {
+    MALE: 'ja-JP-KeitaNeural', 
+    FEMALE: 'ja-JP-NanamiNeural'
+  },
+  // Add more languages as needed
+};
+
+// Default Azure voice if language not found
+export const DEFAULT_AZURE_VOICE = {
+  MALE: 'en-US-GuyNeural',
+  FEMALE: 'en-US-JennyNeural'
+};
+
+// OpenAI voices mapped to approximate language/gender preferences
+// Note: OpenAI voices don't correspond directly to languages, this is an approximation
+export const OPENAI_VOICES = {
+  ALL: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'], // All available voices
+  // Voice characteristics based on OpenAI's documentation
+  CHARACTERISTICS: {
+    'alloy': { gender: 'NEUTRAL', tone: 'BALANCED' },
+    'echo': { gender: 'MALE', tone: 'DEEP' },
+    'fable': { gender: 'FEMALE', tone: 'EXPRESSIVE' },
+    'onyx': { gender: 'MALE', tone: 'AUTHORITATIVE' },
+    'nova': { gender: 'FEMALE', tone: 'FRIENDLY' },
+    'shimmer': { gender: 'FEMALE', tone: 'BRIGHT' }
+  },
+  // Voice recommendations by language and gender
+  // This is subjective and can be adjusted based on preference
+  RECOMMENDED: {
+    DEFAULT: {
+      MALE: 'onyx',
+      FEMALE: 'nova',
+      NEUTRAL: 'alloy'
+    },
+    // Romance languages
+    IT: {
+      MALE: 'echo',
+      FEMALE: 'nova'
+    },
+    ES: {
+      MALE: 'echo',
+      FEMALE: 'shimmer'
+    },
+    FR: {
+      MALE: 'echo',
+      FEMALE: 'fable'
+    },
+    PT: {
+      MALE: 'onyx',
+      FEMALE: 'shimmer'
+    },
+    // Germanic languages
+    DE: {
+      MALE: 'onyx',
+      FEMALE: 'fable'
+    },
+    EN: {
+      MALE: 'echo',
+      FEMALE: 'nova'
+    },
+    // Other language families
+    ZH: {
+      MALE: 'echo',
+      FEMALE: 'shimmer'
+    },
+    JA: {
+      MALE: 'echo',
+      FEMALE: 'nova'
+    },
+    RU: {
+      MALE: 'onyx',
+      FEMALE: 'fable'
+    }
+    // Add more languages as needed
+  }
+};
+
+// Default OpenAI voice
+export const DEFAULT_OPENAI_VOICE = 'alloy';
+
+// Provider configurations
+export const PROVIDER_CONFIG = {
+  azure: {
+    defaultVoice: DEFAULT_AZURE_VOICE.FEMALE,
+    defaultRegion: 'westeurope',
+    defaultModel: null, // Azure doesn't use model parameter in the same way
+    endpoint: (region: string) => 
+      `https://${region}.tts.speech.microsoft.com/cognitiveservices/v1`,
+    outputFormat: 'audio-24khz-48kbitrate-mono-mp3'
+  },
+  openai: {
+    defaultVoice: DEFAULT_OPENAI_VOICE,
+    defaultModel: 'tts-1',
+    voices: OPENAI_VOICES.ALL,
+    endpoint: 'https://api.openai.com/v1/audio/speech'
+  }
+};
+
+/**
+ * Gets appropriate voice for the selected provider and language
+ * 
+ * @param {string} lang - Language code (e.g., 'IT', 'EN')
+ * @param {string} provider - TTS provider ('azure' or 'openai')
+ * @param {string} voiceType - Voice gender preference ('MALE' or 'FEMALE')
+ * @returns {string} Voice identifier for the selected provider
+ */
+export function getTTSVoice(
+  lang?: string, 
+  provider: 'azure' | 'openai' = 'azure', 
+  voiceType: 'MALE' | 'FEMALE' | 'NEUTRAL' = 'FEMALE'
+): string {
+  // Normalize language code
+  const voiceLang = (lang || 'EN').toUpperCase();
+  
+  // Handle different providers
+  if (provider.toLowerCase() === 'openai') {
+    // For OpenAI, get recommended voice by language and gender
+    const langMap = OPENAI_VOICES.RECOMMENDED[voiceLang as keyof typeof OPENAI_VOICES.RECOMMENDED] || OPENAI_VOICES.RECOMMENDED.DEFAULT;
+    return langMap[voiceType as keyof typeof langMap] || OPENAI_VOICES.RECOMMENDED.DEFAULT[voiceType] || DEFAULT_OPENAI_VOICE;
+  } else {
+    // For Azure, get neural voice by language and gender
+    const langVoices = AZURE_VOICES[voiceLang as keyof typeof AZURE_VOICES] || DEFAULT_AZURE_VOICE;
+    return langVoices[voiceType as keyof typeof langVoices] || langVoices.FEMALE || DEFAULT_AZURE_VOICE.FEMALE;
+  }
+}
+
+/**
+ * Validates if a voice is supported by the provider
+ * 
+ * @param {string} voice - Voice identifier to validate
+ * @param {string} provider - TTS provider ('azure' or 'openai')
+ * @returns {boolean} True if voice is valid for the provider
+ */
+export function isValidVoice(voice: string, provider: 'azure' | 'openai'): boolean {
+  if (provider.toLowerCase() === 'openai') {
+    return OPENAI_VOICES.ALL.includes(voice);
+  }
+  
+  // For Azure, check if it follows the format pattern (simple validation)
+  return /^[a-z]{2}-[A-Z]{2}-[A-Za-z]+Neural$/.test(voice);
+}
+
+/**
+ * Gets default voice for the provider
+ * 
+ * @param {string} provider - TTS provider ('azure' or 'openai')
+ * @param {string} voiceType - Voice gender preference ('MALE' or 'FEMALE')
+ * @returns {string} Default voice for the provider
+ */
+export function getDefaultVoice(
+  provider: 'azure' | 'openai', 
+  voiceType: 'MALE' | 'FEMALE' = 'FEMALE'
+): string {
+  if (provider.toLowerCase() === 'openai') {
+    return OPENAI_VOICES.RECOMMENDED.DEFAULT[voiceType] || DEFAULT_OPENAI_VOICE;
+  } else {
+    return DEFAULT_AZURE_VOICE[voiceType] || DEFAULT_AZURE_VOICE.FEMALE;
+  }
+}
+
+/**
+ * Get appropriate default region for the provider
+ * 
+ * @param provider - TTS provider ('azure' or 'openai')
+ * @returns Default region for the provider
+ */
+export function getDefaultRegion(provider: 'azure' | 'openai'): string | null {
+  return (PROVIDER_CONFIG[provider] as { defaultRegion: string }).defaultRegion || null;
+}
+
+/**
+ * Get appropriate default model for the provider
+ * 
+ * @param provider - TTS provider ('azure' or 'openai')
+ * @returns Default model for the provider
+ */
+export function getDefaultModel(provider: 'azure' | 'openai'): string | null {
+  return (PROVIDER_CONFIG[provider] as { defaultModel: string }).defaultModel || null;
+}
+
+/**
+ * Ensures voice is valid for provider, or returns default
+ * 
+ * @param voice - Voice to validate
+ * @param provider - TTS provider ('azure' or 'openai')
+ * @param voiceType - Fallback voice type if invalid
+ * @returns Valid voice for the provider
+ */
+export function ensureValidVoice(
+  voice: string, 
+  provider: 'azure' | 'openai',
+  voiceType: 'MALE' | 'FEMALE' = 'FEMALE'
+): string {
+  if (!voice || !isValidVoice(voice, provider)) {
+    return getDefaultVoice(provider, voiceType);
+  }
+  return voice;
+}
+
+/**
+ * Creates the appropriate provider-specific TTS configuration
+ * 
+ * @param config - Base TTS configuration
+ * @returns Provider-specific configuration with defaults
+ */
+export function createTTSConfiguration(config: Partial<TTSConfig>): TTSConfig {
+  const provider = config.provider || 'azure';
+  const voiceType = (config as { voiceType?: 'MALE' | 'FEMALE' }).voiceType || 'FEMALE';
+  
+  return {
+    provider,
+    voice: config.voice || getDefaultVoice(provider, voiceType),
+    model: config.model || getDefaultModel(provider),
+    region: config.region || getDefaultRegion(provider),
+    tenant: config.tenant || 'www.aisuru.com',
+    voiceType
+  } as TTSConfig;
+}