Fix TTS module initialization and dependency issues. Update module IDs for consistency, improve circular dependency detection, and fix UI Controller event handling.

2025-04-04 19:15:28 +00:00
parent 02c7b9ef28
commit 49a5af252c
33 changed files with 7227 additions and 4060 deletions
@@ -9,9 +9,23 @@ class TextBufferModule extends BaseModule {
    constructor() {
        super('text-buffer', 'Text Buffer');
        this.buffer = '';
-        this.sentenceEndRegex = /[.!?]\s+/g;  // Detect sentence endings
-        this.onSentenceReadyCallback = null;   // Callback for complete sentences
-        this.processingLock = false;           // Lock to prevent concurrent processing
+        this.sentenceEndRegex = /[.!?]\s+/g;
+        this.onSentenceReadyCallback = null;
+        this.processingLock = false;
+        this.processingQueue = [];
+        this.isProcessingActive = false;
+        
+        // Bind methods using parent's bindMethods utility
+        this.bindMethods([
+            'addText',
+            'processNextFromQueue',
+            'processSentences',
+            'processNextSentence',
+            'clear',
+            'getBuffer',
+            'getStatus',
+            'setOnSentenceReady'
+        ]);
    }

    /**
@@ -20,6 +34,22 @@ class TextBufferModule extends BaseModule {
     */
    async initialize() {
        try {
+            // Use parent's addEventListener for automatic cleanup
+            this.addEventListener(document, 'ui:paragraph:complete', (event) => {
+                if (this.processingQueue.length > 0 && !this.isProcessingActive) {
+                    console.log('TextBuffer: Previous paragraph complete, processing next from queue');
+                    this.processNextFromQueue();
+                }
+            });
+            
+            // Use parent's addEventListener for automatic cleanup
+            this.addEventListener(document, 'animation:complete', () => {
+                if (this.processingQueue.length > 0 && !this.isProcessingActive) {
+                    console.log('TextBuffer: Animations complete, processing next from queue');
+                    this.processNextFromQueue();
+                }
+            });
+            
            this.reportProgress(100, "Text buffer ready");
            return true;
        } catch (error) {
@@ -36,6 +66,11 @@ class TextBufferModule extends BaseModule {
        if (typeof callback === 'function') {
            this.onSentenceReadyCallback = callback;
            console.log("Text Buffer: Sentence ready callback set");
+            
+            // Process any queued text immediately
+            if (this.processingQueue.length > 0 && !this.isProcessingActive) {
+                this.processNextFromQueue();
+            }
        } else {
            console.warn("Text Buffer: Invalid sentence ready callback provided");
        }
@@ -50,6 +85,30 @@ class TextBufferModule extends BaseModule {
        
        console.log(`TextBuffer: Adding text: "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}"`);
        
+        // Add to processing queue instead of directly to buffer
+        this.processingQueue.push(text);
+        
+        // Process the queue if not already processing
+        if (!this.isProcessingActive && this.onSentenceReadyCallback) {
+            this.processNextFromQueue();
+        } else {
+            console.log('TextBuffer: Text queued for processing');
+        }
+    }
+    
+    /**
+     * Process the next text fragment from the queue
+     */
+    processNextFromQueue() {
+        if (this.processingQueue.length === 0 || this.isProcessingActive) {
+            return;
+        }
+        
+        this.isProcessingActive = true;
+        const text = this.processingQueue.shift();
+        
+        console.log(`TextBuffer: Processing next fragment from queue, remaining: ${this.processingQueue.length}`);
+        
        // Add text to buffer
        this.buffer += text;
        
@@ -89,14 +148,22 @@ class TextBufferModule extends BaseModule {
            if (!foundSentence) {
                // No complete sentences yet
                this.processingLock = false;
+                this.isProcessingActive = false;
+                
+                // Use parent's dispatchEvent method
+                super.dispatchEvent('buffer:waiting', { 
+                    remainingText: this.buffer,
+                    queueLength: this.processingQueue.length
+                });
                return;
            }
            
-            // Process each complete sentence
+            // Process the next complete sentence
            this.processNextSentence();
        } catch (error) {
            console.error("Error processing sentences:", error);
            this.processingLock = false;
+            this.isProcessingActive = false;
        }
    }

@@ -121,6 +188,7 @@ class TextBufferModule extends BaseModule {
        if (endIndex === -1) {
            // No complete sentence found
            this.processingLock = false;
+            this.isProcessingActive = false;
            return;
        }
        
@@ -131,24 +199,52 @@ class TextBufferModule extends BaseModule {
        
        console.log(`TextBuffer: Processing sentence: "${sentence.trim()}"`);
        
+        // Use parent's dispatchEvent method
+        super.dispatchEvent('buffer:sentence', {
+            sentence: sentence,
+            remaining: this.buffer.length
+        });
+        
        // Call the callback if set
        if (this.onSentenceReadyCallback) {
            this.onSentenceReadyCallback(sentence, () => {
                // After processing is complete, check for more sentences
-                setTimeout(() => {
-                    if (this.buffer.length > 0) {
+                this.processingLock = false; // Release lock immediately to allow processing of next sentence
+                
+                // Check if there are more sentences to process
+                if (this.buffer.length > 0) {
+                    // Use requestAnimationFrame to prevent stack overflow and ensure UI update between sentences
+                    requestAnimationFrame(() => {
                        this.processSentences();
-                    } else {
-                        this.processingLock = false;
-                    }
-                }, 0);
+                    });
+                } else if (this.processingQueue.length > 0) {
+                    // No more sentences in buffer but we have more text in the queue
+                    requestAnimationFrame(() => {
+                        this.isProcessingActive = false;
+                        this.processNextFromQueue();
+                    });
+                } else {
+                    // All processed
+                    this.isProcessingActive = false;
+                    super.dispatchEvent('buffer:empty', {});
+                }
            });
        } else {
-            // No callback set, just process the next sentence
+            // No callback set, just release lock and continue processing
+            this.processingLock = false;
+            
            if (this.buffer.length > 0) {
-                this.processSentences();
+                // Use requestAnimationFrame instead of setTimeout for better performance
+                requestAnimationFrame(() => {
+                    this.processSentences();
+                });
+            } else if (this.processingQueue.length > 0) {
+                requestAnimationFrame(() => {
+                    this.isProcessingActive = false;
+                    this.processNextFromQueue();
+                });
            } else {
-                this.processingLock = false;
+                this.isProcessingActive = false;
            }
        }
    }
@@ -158,6 +254,9 @@ class TextBufferModule extends BaseModule {
     */
    clear() {
        this.buffer = '';
+        this.processingQueue = [];
+        this.isProcessingActive = false;
+        this.processingLock = false;
    }

    /**
@@ -167,6 +266,19 @@ class TextBufferModule extends BaseModule {
    getBuffer() {
        return this.buffer;
    }
+    
+    /**
+     * Get the current processing status
+     * @returns {Object} - Processing status object
+     */
+    getStatus() {
+        return {
+            bufferLength: this.buffer.length,
+            queueLength: this.processingQueue.length,
+            isProcessing: this.isProcessingActive,
+            isLocked: this.processingLock
+        };
+    }
 }

 // Create the singleton instance